/// <summary>
/// Adds a retrieve multiple request to the current OrganizationRequestCollection.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requests">The requests.</param>
/// <param name="columnSet">The column set.</param>
/// <param name="columnNameAndValuePairs">The column name and value pairs.</param>
public static void AddRetrieveMultiple <T>(this OrganizationRequestCollection requests, ColumnSet columnSet,
params object[] columnNameAndValuePairs) where T : Entity
{
requests.Add(new RetrieveMultipleRequest {
Query = QueryExpressionFactory.Create <T>(columnSet, columnNameAndValuePairs),
});
}
/// <summary>
/// 批量执行
/// </summary>
/// <param name="service"></param>
/// <param name="ents"></param>
public static void BatchExecute(this IOrganizationService service, OrganizationRequestCollection ents)
{
if (ents == null)
{
return;
}
List <dynamic> list = new List <dynamic>();
try
{
foreach (var item in ents)
{
if (item is CreateRequest)
{
CreateResponse resp = (CreateResponse)service.Execute((CreateRequest)item);
list.Add(new { id = resp.id, name = ((CreateRequest)item).Target.LogicalName });
}
else
{
service.Execute(item);
}
}
}
catch (Exception ex)
{
//删除创建的记录
foreach (var item in list)
{
service.Delete(item.name, item.id);
}
throw new Exception(ex.Message);
}
}
public BulkResponse Write(IOrganizationService service, Dictionary <string, OrganizationRequest> requestsToBeProcessed)
{
BulkResponse bulkWriteResponse = new BulkResponse();
bulkWriteResponse.Responses = new List <BulkResponseItem>();
int batchNumber = 0;
int recordsToProcessCount = requestsToBeProcessed.Count;
while (recordsToProcessCount > _batchSize || recordsToProcessCount > 0)
{
Dictionary <string, OrganizationRequest> currentBatchOfRequests = requestsToBeProcessed.Skip(batchNumber * _batchSize).Take(_batchSize).ToDictionary(x => x.Key, x => x.Value);
OrganizationRequestCollection orgReqs = new OrganizationRequestCollection();
orgReqs.AddRange(currentBatchOfRequests.Values.ToList());
ExecuteMultipleResponse response = ExecuteMultiple(service, orgReqs);
List <BulkResponseItem> bulkResponses = ReadExecuteMultipleResponse(response, currentBatchOfRequests);
bulkWriteResponse.Responses.AddRange(bulkResponses);
bulkWriteResponse.HasErrors = response.IsFaulted;
recordsToProcessCount = recordsToProcessCount - currentBatchOfRequests.Count;
batchNumber++;
}
return(bulkWriteResponse);
}
protected override void ExecuteMultipleWithRetry(List <EntityWrapper> entities, Func <EntityWrapper, OrganizationRequest> orgRequest)
{
var requests = new OrganizationRequestCollection();
requests.AddRange(entities.Select(wrapper => orgRequest(wrapper)).ToArray());
int cnt = 0;
List <ExecuteMultipleResponseItem> responseWithResults = new List <ExecuteMultipleResponseItem>();
foreach (OrganizationRequest request in requests)
{
try
{
OrganizationResponse response = new UpsertResponse()
{
};
responseWithResults.Add(new ExecuteMultipleResponseItem()
{
Response = response, RequestIndex = cnt
});
}
catch (FaultException <OrganizationServiceFault> ex)
{
responseWithResults.Add(new ExecuteMultipleResponseItem()
{
Fault = ex.Detail, RequestIndex = cnt
});
}
cnt++;
}
PopulateExecutionResults(entities, responseWithResults);
}
public override void ProcessData()
{
var successfulRequests = 0;
var optionSetData = InputFile.Worksheets[ConfigurationFile.WorkSheets.OptionSets].Data;
var entityData = InputFile.Worksheets[ConfigurationFile.WorkSheets.Entities].Data;
if (entityData.Count > 0 || optionSetData.Count > 0)
{
var entityRequests = new OrganizationRequestCollection();
var entityMapper = new CreateEntityRequestDataMapper(InputFile.Worksheets[ConfigurationFile.WorkSheets.Entities].Columns, OrgLcId);
entityRequests.AddRange(MapDataToRequests(entityMapper, entityData));
var optionSetMapper = new CreateOptionSetRequestDataMapper(InputFile.Worksheets[ConfigurationFile.WorkSheets.OptionSets].Columns, OrgLcId);
entityRequests.AddRange(MapDataToRequests(optionSetMapper, optionSetData));
successfulRequests = ExecuteRequests(entityRequests);
}
var attributeData = InputFile.Worksheets[ConfigurationFile.WorkSheets.Attributes].Data;
var oneToManyData = InputFile.Worksheets[ConfigurationFile.WorkSheets.OneToManyRelationships].Data;
var manyToManyData = InputFile.Worksheets[ConfigurationFile.WorkSheets.ManyToManyRelationships].Data;
if (attributeData.Count > 0 || oneToManyData.Count > 0 || manyToManyData.Count > 0)
{
var otherRequests = new OrganizationRequestCollection();
var attributeMapper = new CreateAttributeRequestDataMapper(InputFile.Worksheets[ConfigurationFile.WorkSheets.Attributes].Columns, OrgLcId);
otherRequests.AddRange(MapDataToRequests(attributeMapper, attributeData));
var oneToManyMapper = new CreateOneToManyRequestDataMapper(InputFile.Worksheets[ConfigurationFile.WorkSheets.OneToManyRelationships].Columns, OrgLcId);
otherRequests.AddRange(MapDataToRequests(oneToManyMapper, oneToManyData));
var manyToManyMapper = new CreateManyToManyRequestDataMapper(InputFile.Worksheets[ConfigurationFile.WorkSheets.ManyToManyRelationships].Columns, OrgLcId);
otherRequests.AddRange(MapDataToRequests(manyToManyMapper, manyToManyData));
successfulRequests += ExecuteRequests(otherRequests);
}
if (successfulRequests > 0)
{
Service.Execute(new PublishAllXmlRequest());
}
}
public override void ProcessData()
{
var successfulRequests = 0;
var attributeData = InputFile.Worksheets[ConfigurationFile.WorkSheets.Attributes].Data;
var oneToManyData = InputFile.Worksheets[ConfigurationFile.WorkSheets.OneToManyRelationships].Data;
var manyToManyData = InputFile.Worksheets[ConfigurationFile.WorkSheets.ManyToManyRelationships].Data;
if (attributeData.Count > 0 || oneToManyData.Count > 0 || manyToManyData.Count > 0)
{
var attributeRelationshipRequests = new OrganizationRequestCollection();
attributeRelationshipRequests.AddRange(MapDataToRequests(MapAttributes, attributeData));
attributeRelationshipRequests.AddRange(MapDataToRequests(MapOneToMany, oneToManyData));
attributeRelationshipRequests.AddRange(MapDataToRequests(MapManyToMany, manyToManyData));
successfulRequests = ExecuteRequests(attributeRelationshipRequests);
}
var optionSetData = InputFile.Worksheets[ConfigurationFile.WorkSheets.OptionSets].Data;
var entityData = InputFile.Worksheets[ConfigurationFile.WorkSheets.Entities].Data;
if (entityData.Count > 0 || optionSetData.Count > 0)
{
var entitiesRequests = new OrganizationRequestCollection();
entitiesRequests.AddRange(MapDataToRequests(MapEntities, entityData));
entitiesRequests.AddRange(MapDataToRequests(MapOptionSets, optionSetData));
successfulRequests = ExecuteRequests(entitiesRequests);
}
if (successfulRequests > 0)
{
Service.Execute(new PublishAllXmlRequest());
}
}
public static bool UpdateAndPublishSingle(CrmServiceClient client, List <Entity> webResources)
{
//CRM 2011 < UR12
try
{
OrganizationRequestCollection requests = CreateUpdateRequests(webResources);
foreach (OrganizationRequest request in requests)
{
client.Execute(request);
OutputLogger.WriteToOutputWindow("Uploaded Web Resource", MessageType.Info);
}
string publishXml = CreatePublishXml(webResources);
PublishXmlRequest publishRequest = CreatePublishRequest(publishXml);
client.Execute(publishRequest);
OutputLogger.WriteToOutputWindow("Published Web Resource(s)", MessageType.Info);
return(true);
}
catch (FaultException <OrganizationServiceFault> crmEx)
{
OutputLogger.WriteToOutputWindow("Error Updating And Publishing Web Resource(s) To CRM: " +
crmEx.Message + Environment.NewLine + crmEx.StackTrace, MessageType.Error);
return(false);
}
catch (Exception ex)
{
OutputLogger.WriteToOutputWindow("Error Updating And Publishing Web Resource(s) To CRM: " +
ex.Message + Environment.NewLine + ex.StackTrace, MessageType.Error);
return(false);
}
}
/// <summary>
/// Adds a retrieve multiple request to the current OrganizationRequestCollection.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requests">The requests.</param>
/// <param name="anonymousTypeInitializer">The anonymous type initializer.</param>
/// <param name="columnNameAndValuePairs">The column name and value pairs.</param>
public static void AddRetrieveMultiple <T>(this OrganizationRequestCollection requests, Expression <Func <T, object> > anonymousTypeInitializer,
params object[] columnNameAndValuePairs) where T : Entity
{
requests.Add(new RetrieveMultipleRequest {
Query = QueryExpressionFactory.Create(anonymousTypeInitializer, columnNameAndValuePairs),
});
}
/// <summary>
/// Execute Multiple and return fail count.
/// </summary>
/// <param name="requestCollection">Request Collection</param>
/// <param name="service">Organization Service</param>
/// <param name="continueOnError">Continue on Error</param>
/// <returns>Failed Record Count</returns>
private static int ProcessExecuteMultipleAndReturnFailCount(OrganizationRequestCollection requestCollection, IOrganizationService service, bool continueOnError)
{
if (service != null)
{
int failCount = 0;
var requestWithResults = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = continueOnError,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
requestWithResults.Requests.AddRange(requestCollection);
ExecuteMultipleResponse responseWithResults =
(ExecuteMultipleResponse)service.Execute(requestWithResults);
// Display the results returned in the responses.
foreach (var responseItem in responseWithResults.Responses)
{
// An error has occurred.
if (responseItem.Fault != null)
{
failCount++;
}
}
return(failCount);
}
return(-1);
}
private OrganizationRequestCollection GetOrgRequestsForCreateOrUpdate(Dictionary <string, Entity> recordsToBeProcessed, Operation operation)
{
OrganizationRequestCollection orgReqs = new OrganizationRequestCollection();
foreach (var recordKvp in recordsToBeProcessed)
{
// Guid requestId = Guid.NewGuid();
if (operation == Operation.Create)
{
CreateRequest createRequest = new CreateRequest {
Target = recordKvp.Value
};
orgReqs.Add(createRequest);
}
else if (operation == Operation.Update)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = recordKvp.Value
};
orgReqs.Add(updateRequest);
}
}
return(orgReqs);
}
private static void ExecuteMultipleRequests(TraceLogger logger, CrmServiceClient service,
OrganizationRequestCollection requests, int batchIndex)
{
var response = (ExecuteMultipleResponse)service.Execute(new ExecuteMultipleRequest
{
Requests = requests,
Settings = new ExecuteMultipleSettings
{
ContinueOnError = true,
ReturnResponses = false
}
});
if (response.IsFaulted)
{
foreach (var item in response.Responses)
{
var itemIndex = (batchIndex * QUEUEITEMBATCHSIZE) + item.RequestIndex;
var itemRequest = (AddToQueueRequest)requests[item.RequestIndex];
logger.Log(
$"Item {itemIndex} - There was an error queuing the item with the id:{itemRequest.Target} to queue:{itemRequest.DestinationQueueId}",
TraceEventType.Information);
logger.Log(item.Fault.Message);
}
}
requests.Clear();
}
public static bool UpdateAndPublishSingle(CrmServiceClient client, List <Entity> webResources)
{
//CRM 2011 < UR12
try
{
OrganizationRequestCollection requests = CreateUpdateRequests(webResources);
foreach (OrganizationRequest request in requests)
{
client.Execute(request);
OutputLogger.WriteToOutputWindow(Resource.Message_UploadedWebResource, MessageType.Info);
}
string publishXml = CreatePublishXml(webResources);
PublishXmlRequest publishRequest = CreatePublishRequest(publishXml);
client.Execute(publishRequest);
OutputLogger.WriteToOutputWindow(Resource.Message_PublishedWebResources, MessageType.Info);
return(true);
}
catch (Exception ex)
{
ExceptionHandler.LogException(Logger, Resource.ErrorMessage_ErrorUpdatingPublishingWebResources, ex);
return(false);
}
}
public void Commit()
{
var requests = new OrganizationRequestCollection();
var transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
Added.ForEach(requests.Add);
Modified.ForEach(requests.Add);
Deleted.ForEach(requests.Add);
Added.Clear();
Modified.Clear();
Deleted.Clear();
try
{
for (int i = 0; i < requests.Count; i++)
{
if ((i + 1) % _batchSize != 0)
{
transactionRequest.Requests.Add(requests[i]);
}
else
{
transactionRequest.Requests.Add(requests[i]);
var response = _service.Execute(transactionRequest);
transactionRequest = new ExecuteTransactionRequest
{
Requests = new OrganizationRequestCollection()
};
}
if ((i == requests.Count - 1) && transactionRequest.Requests.Count > 0)
{
var response = _service.Execute(transactionRequest);
}
}
}
catch (FaultException<OrganizationServiceFault> fault)
{
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < transactionRequest.Requests.Count)
{
var errMsg =
string.Format(
"The input request collection contains {0} requests, which exceeds the maximum allowed {1}",
transactionRequest.Requests.Count, maxBatchSize);
throw new InvalidOperationException(errMsg, fault);
}
}
throw;
}
}
public OrganizationResponseCollection ExecuteTransaction(OrganizationRequestCollection requests, bool?returnResponses)
{
return(Execute <ExecuteTransactionResponse>(
new ExecuteTransactionRequest()
{
Requests = requests,
ReturnResponses = returnResponses
}).Responses);
}
public ExecuteTransactionResponse ExecuteTransactionRequests(OrganizationRequestCollection collectionRequests, bool returnResponses = true)
{
var request = new ExecuteTransactionRequest
{
Requests = collectionRequests,
ReturnResponses = returnResponses
};
return((ExecuteTransactionResponse)OrganizationService.Execute(request));
}
public BulkResponse Read(IOrganizationService service, Dictionary <string, QueryExpression> queriesToBeProcessed)
{
OrganizationRequestCollection orgReqs = GetOrgRequestsForRetrieveMultiple(queriesToBeProcessed);
ExecuteMultipleResponse response = ExecuteMultiple(service, orgReqs);
BulkResponse bulkWriteResponse = ReadExecuteMultipleResponse(response, queriesToBeProcessed.Keys.ToList());
return(bulkWriteResponse);
}
private void ExecuteMultipleRequests(List <OrganizationRequest> requests)
{
WorkAsync(new WorkAsyncInfo
{
Message = "Creating entity records",
Work = (worker, args) =>
{
var responses = new ExecuteMultipleResponseItemCollection();
var lists = SplitList(requests);
var count = 0;
foreach (var list in lists)
{
var collection = new OrganizationRequestCollection();
collection.AddRange(list);
var req = new ExecuteMultipleRequest
{
Requests = collection,
Settings = new ExecuteMultipleSettings {
ContinueOnError = true, ReturnResponses = false
}
};
count++;
var response = (ExecuteMultipleResponse)Service.Execute(req);
SendMessageToStatusBar?.Invoke(this, new StatusBarMessageEventArgs(count / requests.Count, $"{count}/{requests.Count} records created"));
responses.AddRange(response.Responses);
}
args.Result = responses;
},
PostWorkCallBack = (args) =>
{
if (args.Error != null)
{
MessageBox.Show($"Something bad happened. Error message:\n{args.Error}", @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var result = (ExecuteMultipleResponseItemCollection)args.Result;
if (result.Count == 0)
{
MessageBox.Show($"{requests.Count} records successfully created");
}
else
{
var createdCount = requests.Count - result.Count;
MessageBox.Show($"{createdCount}/{requests.Count} records created. See error log for details.");
foreach (var response in result)
{
LogError(response.Fault.Message);
}
}
},
IsCancelable = true,
});
}
public void ExecuteMultiple()
{
testOrgService.ExecutionResponse = new ExecuteMultipleResponse();
OrganizationRequestCollection orgRequests = new OrganizationRequestCollection();
ExecuteMultipleResponse actual = null;
FluentActions.Invoking(() => actual = testOrgService.ExecuteMultiple(orgRequests))
.Should()
.NotThrow();
}
private static void DeployWebResource(DTE dte, CrmServiceClient crmServiceClient, string crmUrl, string fullFileName, string fileName, Guid webResourceId)
{
var requests = new OrganizationRequestCollection();
var webResource = new Entity("webresource")
{
Id = webResourceId
};
webResource["content"] = Convert.ToBase64String(File.ReadAllBytes(fullFileName));
var request = new UpdateRequest {
Target = webResource
};
requests.Add(request);
var publishXml = $"<importexportxml><webresources><webresource>{webResource.Id}</webresource></webresources></importexportxml>";
var pubRequest = new PublishXmlRequest {
ParameterXml = publishXml
};
requests.Add(pubRequest);
var multipleRequest = new ExecuteMultipleRequest
{
Requests = requests,
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
UtilityPackage.SetDTEStatusBar(dte, $"[{crmUrl}] Updating & Publishing WebResource");
var multipleResponse = (ExecuteMultipleResponse)crmServiceClient.Execute(multipleRequest);
foreach (var response in multipleResponse.Responses)
{
if (response.Fault == null)
{
continue;
}
UtilityPackage.SetDTEStatusBar(dte, $"[{crmUrl}] Deploy WebResource failed");
return;
}
var webResourceName = string.Empty;
var selected = DevKitSetting.SelectedWebResources.Where(x => x.FullFileName == fullFileName).FirstOrDefault();
if (selected != null)
{
webResourceName = selected.WebResourceName;
}
UtilityPackage.SetDTEStatusBar(dte, $"Deployed: [{fileName}] to [{webResourceName}]");
}
static void Main()
{
var connectionString = "AuthType=Office365;[email protected]; Password=;Url=https://.crm6.dynamics.com";
var crmSvc = new CrmServiceClient(connectionString);
var settings = new ImportSettings();
using (var serviceProxy = crmSvc.OrganizationServiceProxy)
{
//Create request collection
var request = new OrganizationRequestCollection()
{
new CreateRequest
{
Target = new Entity("account")
{
["name"] = "Packt Account"
}
},
new CreateRequest
{
Target = new Entity("contact")
{
["firstname"] = "Packt",
["lastname"] = "Contact"
}
}
};
//Create Transaction and pass previously created request collection
var requestToCreateRecords = new ExecuteMultipleRequest()
{
// Create an empty organization request collection.
Requests = request,
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
}
};
//Execute requests within the transaction
var responseForCreateRecords = (ExecuteMultipleResponse)serviceProxy.Execute(requestToCreateRecords);
// Display the results of each response.
foreach (var responseItem in responseForCreateRecords.Responses)
{
Console.WriteLine("Created record with GUID {0}", responseItem.Response.Results["id"].ToString());
}
}
}
private static OrganizationRequestCollection ToOrganizationRequestCollection(IEnumerable <OrganizationRequest> requests)
{
var collection = new OrganizationRequestCollection();
foreach (var request in requests)
{
collection.Add(request);
}
return(collection);
}
public ExecuteMultipleResponse ExecuteMultipleRequests(OrganizationRequestCollection collectionRequests, bool continueOnError = true, bool returnResponses = true)
{
var request = new ExecuteMultipleRequest();
request.Requests = collectionRequests;
request.Settings = new ExecuteMultipleSettings
{
ContinueOnError = continueOnError,
ReturnResponses = returnResponses
};
return((ExecuteMultipleResponse)OrganizationService.Execute(request));
}
public BulkResponse Write(IOrganizationService service, Dictionary <string, Entity> recordsToBeProcessed, Operation operation)
{
OrganizationRequestCollection orgReqs = GetOrgRequestsForCreateOrUpdate(recordsToBeProcessed, operation);
ExecuteMultipleResponse response = ExecuteMultiple(service, orgReqs);
BulkResponse bulkWriteResponse = ReadExecuteMultipleResponse(response, recordsToBeProcessed.Keys.ToList());
return(bulkWriteResponse);
}
/// <summary>
/// Converts a collection of type <see cref="OrganizationRequest"/> to a single <see cref="ExecuteMultipleRequest"/> instance
/// </summary>
/// <typeparam name="T">The typeof<see cref="OrganizationRequest"/></typeparam>
/// <param name="requests">The collection of requests representing the batch</param>
/// <param name="batchSettings">The desired settings</param>
/// <returns>A single <see cref="ExecuteMultipleRequest"/> instance</returns>
public static ExecuteMultipleRequest AsBatch <T>(this IEnumerable <T> requests, ExecuteMultipleSettings batchSettings)
where T : OrganizationRequest
{
var batch = new OrganizationRequestCollection();
batch.AddRange(requests);
return(new ExecuteMultipleRequest()
{
Requests = batch,
Settings = batchSettings
});
}
public ExecuteMultipleResponse ExecuteMultiple(OrganizationRequestCollection requests, bool ContinueOnError, bool ReturnResponses)
{
ExecuteMultipleRequest requestWithResults = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = ContinueOnError,
ReturnResponses = ReturnResponses
},
Requests = requests
};
return((ExecuteMultipleResponse)ServiceProxy.Execute(requestWithResults));
}
private OrganizationRequestCollection GetOrgRequestsForRetrieveMultiple(Dictionary <string, QueryExpression> queriesToBeProcessed)
{
OrganizationRequestCollection orgReqs = new OrganizationRequestCollection();
foreach (var queryRecord in queriesToBeProcessed)
{
RetrieveMultipleRequest retrieveMultipleRequest = new RetrieveMultipleRequest {
Query = queryRecord.Value
};
orgReqs.Add(retrieveMultipleRequest);
}
return(orgReqs);
}
private static OrganizationRequestCollection CreateUpdateRequests(List <Entity> webResources)
{
OrganizationRequestCollection requests = new OrganizationRequestCollection();
foreach (Entity webResource in webResources)
{
UpdateRequest request = new UpdateRequest {
Target = webResource
};
requests.Add(request);
}
return(requests);
}
public static void executeMultipleWithRequests(OrganizationRequestCollection requests, string logFileName, IOrganizationService service)
{
ExecuteMultipleRequest multipleRequest = new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
multipleRequest.Requests = requests;
//This is how to get responses
ExecuteMultipleResponse executeResponse = (ExecuteMultipleResponse)service.Execute(multipleRequest);
if (executeResponse.Results != null)
{
//Loop through responses
foreach (ExecuteMultipleResponseItem responseItem in executeResponse.Responses)
{
if (responseItem.Response != null)
{
//Awesome, command completed as expected
//success++;
}
else if (responseItem.Fault != null)
{
OrganizationRequest req = multipleRequest.Requests[responseItem.RequestIndex];
if (req.Parameters.Contains("Target"))
{
Entity entity = (Entity)req.Parameters["Target"];
GeneralHelper.WriteToText(entity.Id + ";" + req.RequestName + "-" + responseItem.Fault.Message, @"C:\sahibinden\migration_" + logFileName + "_" + DateTime.Now.ToShortDateString() + ".txt");
}
else
{
GeneralHelper.WriteToText(((AssociateEntitiesRequest)req).Moniker1.Id + ";" + req.RequestName + "-" + responseItem.Fault.Message, @"C:\sahibinden\migration_" + logFileName + "_" + DateTime.Now.ToShortDateString() + ".txt");
}
//Uh oh, error
//error++;
}
else
{
//Error reporting error;
}
}
}
}
private void LogResponses(ExecuteMultipleResponseItemCollection responses, OrganizationRequestCollection requests)
{
foreach (var response in responses)
{
if (response.Fault == null)
{
logger.LogInformation(requests[response.RequestIndex].FormatSuccessMessage());
}
else
{
logger.LogError(FormatFaultException(requests[response.RequestIndex], response.Fault));
}
}
}
/// <summary>
/// Data is assumed to be there, so use TryDelete
/// </summary>
/// <param name="service"></param>
protected virtual void CleanupDataPostInitialization(IOrganizationService service)
{
var totalWatch = new Stopwatch();
totalWatch.Start();
var requests = new OrganizationRequestCollection();
foreach (var id in EntityIds.Where(e => e.Key != "businessunit").SelectMany(entityType => entityType.Value))
{
requests.Add(new DeleteRequest {
Target = Entities[id]
});
}
if (requests.Any())
{
var response = (ExecuteMultipleResponse)service.Execute(
new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = false
},
Requests = requests,
});
ThrowExceptionForFaults(response, requests);
totalWatch.Stop();
Debug.WriteLine("Total Time to delete {0} entities of types {1} (ms): {2}",
requests.Count,
String.Join(", ", requests.Select(s => ((DeleteRequest)s).Target.LogicalName).Distinct()),
totalWatch.ElapsedMilliseconds);
}
List <Guid> businessIds;
if (!EntityIds.TryGetValue("businessunit", out businessIds))
{
return;
}
foreach (var id in businessIds)
{
service.DeleteBusinessUnit(id);
}
}
private void PerformUpdates(IOrganizationService service, OrganizationRequestCollection requests)
{
if (SupportsExecuteMultipleRequest)
{
var response = (ExecuteMultipleResponse)service.Execute(
new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = false
},
Requests = requests
});
if (response.IsFaulted)
{
var fault = response.Responses.First().Fault;
while (fault.InnerFault != null)
{
fault = fault.InnerFault;
}
var errorDetails = string.Empty;
if (fault.ErrorDetails.ContainsKey("CallStack"))
{
errorDetails = Environment.NewLine + fault.ErrorDetails["CallStack"];
}
errorDetails += string.Format("{0}{0}TRACE TEXT:{0}{1}", Environment.NewLine, fault.TraceText);
throw new Exception(fault.Message + errorDetails);
}
}
else
{
foreach (var request in requests)
{
service.Update(((UpdateRequest)request).Target);
}
}
}
private void UpdateWebResources(List<WebResourceItem> items)
{
//TODO: Handle CRM 2011 w/o execute multiple
ExecuteMultipleRequest emRequest = new ExecuteMultipleRequest
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
OrganizationRequestCollection requests = new OrganizationRequestCollection();
string projectName = ((ComboBoxItem)Projects.SelectedItem).Content.ToString();
Project project = GetProjectByName(projectName);
if (project == null)
return;
string publishXml = "<importexportxml><webresources>";
foreach (var webResourceItem in items)
{
Entity webResource = new Entity("webresource") { Id = webResourceItem.WebResourceId };
string filePath = Path.GetDirectoryName(project.FullName) + webResourceItem.BoundFile.Replace("/", "\\");
if (!File.Exists(filePath)) continue;
string content = File.ReadAllText(filePath);
webResource["content"] = EncodeString(content);
UpdateRequest request = new UpdateRequest { Target = webResource };
requests.Add(request);
publishXml += "<webresource>{" + webResource.Id + "}</webresource>";
}
publishXml += "</webresources></importexportxml>";
PublishXmlRequest pubRequest = new PublishXmlRequest { ParameterXml = publishXml };
requests.Add(pubRequest);
emRequest.Requests = requests;
string connString = ((CrmConn)Connections.SelectedItem).ConnectionString;
CrmConnection connection = CrmConnection.Parse(connString);
using (OrganizationService orgService = new OrganizationService(connection))
{
DisplayStatusMessage("Updating & publishing web resources");
ExecuteMultipleResponse emResponse = (ExecuteMultipleResponse)orgService.Execute(emRequest);
foreach (var responseItem in emResponse.Responses)
{
if (responseItem.Fault == null) continue;
//Some error - do something
//TODO: handle error
DisplayStatusMessage(String.Empty);
return;
}
MessageBox.Show("Published");//change to status message that goes away itself
DisplayStatusMessage(String.Empty);
}
}
private void UpdateAndPublishMultiple(CrmConnection connection, ProjectItem projectItem, Guid webResourceId)
{
try
{
ExecuteMultipleRequest emRequest = new ExecuteMultipleRequest
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
OrganizationRequestCollection requests = new OrganizationRequestCollection();
string publishXml = "<importexportxml><webresources>";
Entity webResource = new Entity("webresource") { Id = webResourceId };
string extension = Path.GetExtension(projectItem.FileNames[1]);
string content = extension != null && (extension.ToUpper() != ".TS")
? File.ReadAllText(projectItem.FileNames[1])
: File.ReadAllText(Path.ChangeExtension(projectItem.FileNames[1], ".js"));
webResource["content"] = EncodeString(content);
UpdateRequest request = new UpdateRequest { Target = webResource };
requests.Add(request);
publishXml += "<webresource>{" + webResource.Id + "}</webresource>";
publishXml += "</webresources></importexportxml>";
PublishXmlRequest pubRequest = new PublishXmlRequest { ParameterXml = publishXml };
requests.Add(pubRequest);
emRequest.Requests = requests;
using (OrganizationService orgService = new OrganizationService(connection))
{
_dte.StatusBar.Text = "Updating & publishing web resource...";
_dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationDeploy);
ExecuteMultipleResponse emResponse = (ExecuteMultipleResponse)orgService.Execute(emRequest);
bool wasError = false;
foreach (var responseItem in emResponse.Responses)
{
if (responseItem.Fault == null) continue;
_logger.WriteToOutputWindow(
"Error Updating And Publishing Web Resources To CRM: " + responseItem.Fault.Message + Environment.NewLine + responseItem.Fault.TraceText,
Logger.MessageType.Error);
wasError = true;
}
if (wasError)
MessageBox.Show("Error Updating And Publishing Web Resources To CRM. See the Output Window for additional details.");
else
_logger.WriteToOutputWindow("Updated And Published Web Resource", Logger.MessageType.Info);
}
}
catch (FaultException<OrganizationServiceFault> crmEx)
{
_logger.WriteToOutputWindow("Error Updating And Publishing Web Resource To CRM: " + crmEx.Message + Environment.NewLine + crmEx.StackTrace, Logger.MessageType.Error);
}
catch (Exception ex)
{
_logger.WriteToOutputWindow("Error Updating And Publishing Web Resource To CRM: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
}
_dte.StatusBar.Clear();
_dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationDeploy);
}
private void ThrowExceptionForFaults(ExecuteMultipleResponse response, OrganizationRequestCollection requests)
{
if (!response.IsFaulted) { return; }
var exceptions = new List<Exception>();
foreach (var fault in response.Responses.Select(r => new { r.Fault, r.RequestIndex }))
{
var localFault = fault.Fault;
var target = ((DeleteRequest)requests[fault.RequestIndex]).Target;
if (localFault.ErrorCode == CrmErrorCodes.EntityToDeleteDoesNotExist)
{
Debug.WriteLine("Attempted to Delete Entity that doesn't exist {0} ({1}) - {2}", target.LogicalName, target.Id, localFault.Message);
continue;
}
while (localFault.InnerFault != null)
{
localFault = localFault.InnerFault;
}
var errorDetails = String.Empty;
if (localFault.ErrorDetails.ContainsKey("CallStack"))
{
errorDetails = Environment.NewLine + localFault.ErrorDetails["CallStack"];
}
exceptions.Add(new Exception(localFault.Message + errorDetails));
Debug.WriteLine("Error Deleting {0} ({1}) - {2}{3}", target.LogicalName, target.Id, localFault.Message, errorDetails);
}
if (exceptions.Any())
{
throw new AggregateException("One or more faults occured", exceptions);
}
}
/// <summary>
/// Data is assumed to be there, so use TryDelete
/// </summary>
/// <param name="service"></param>
protected virtual void CleanupDataPostInitialization(IOrganizationService service)
{
var totalWatch = new Stopwatch();
totalWatch.Start();
var requests = new OrganizationRequestCollection();
foreach (var id in EntityIds.Where(e => e.Key != "businessunit").SelectMany(entityType => entityType.Value))
{
requests.Add(new DeleteRequest { Target = Entities[id] });
}
if (requests.Any())
{
var response = (ExecuteMultipleResponse)service.Execute(
new ExecuteMultipleRequest()
{
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = false
},
Requests = requests,
});
ThrowExceptionForFaults(response, requests);
totalWatch.Stop();
Debug.WriteLine("Total Time to delete {0} entities of types {1} (ms): {2}",
requests.Count,
String.Join(", ", requests.Select(s => ((DeleteRequest)s).Target.LogicalName).Distinct()),
totalWatch.ElapsedMilliseconds);
}
List<Guid> businessIds;
if (!EntityIds.TryGetValue("businessunit", out businessIds))
{
return;
}
foreach (var id in businessIds)
{
service.DeleteBusinessUnit(id);
}
}
private void PerformUpdates(IOrganizationService service, OrganizationRequestCollection requests)
{
if (SupportsExecuteMultipleRequest)
{
var response = (ExecuteMultipleResponse)service.Execute(
new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = false
},
Requests = requests
});
if (response.IsFaulted)
{
var fault = response.Responses.First().Fault;
while (fault.InnerFault != null)
{
fault = fault.InnerFault;
}
var errorDetails = string.Empty;
if (fault.ErrorDetails.ContainsKey("CallStack"))
{
errorDetails = Environment.NewLine + fault.ErrorDetails["CallStack"];
}
errorDetails += string.Format("{0}{0}TRACE TEXT:{0}{1}", Environment.NewLine, fault.TraceText);
throw new Exception(fault.Message + errorDetails);
}
}
else
{
foreach (var request in requests)
{
service.Save(((UpdateRequest)request).Target);
}
}
}
private void CopyData(IOrganizationService service, AttributeMetadata from, AttributeMetadata to, Action actions)
{
if (!MigrateData) { return; }
var total = GetRecordCount(service, from);
var count = 0;
Trace("Copying data from {0} to {1}", from.LogicalName, to.LogicalName);
var requests = new OrganizationRequestCollection();
// Grab from and to, and only update if not equal. This is to speed things up if it has failed part way through
foreach (var entity in service.GetAllEntities<Entity>(new QueryExpression(from.EntityLogicalName) { ColumnSet = new ColumnSet(from.LogicalName, to.LogicalName) }))
{
if (count++ % 100 == 0 || count == total)
{
if (requests.Any())
{
PerformUpdates(service, requests);
}
Trace("Copying {0} / {1}", count, total);
requests.Clear();
}
var value = entity.GetAttributeValue<Object>(from.LogicalName);
if (actions.HasFlag(Action.ChangeType) && from.GetType() != to.GetType())
{
value = CopyValue(from, to, value);
}
var toValue = entity.GetAttributeValue<Object>(to.LogicalName);
if (value != null)
{
if (value.Equals(toValue)) continue;
entity.Attributes[to.LogicalName] = value;
requests.Add(new UpdateRequest { Target = entity });
}
else if (toValue != null)
{
entity.Attributes[to.LogicalName] = null;
requests.Add(new UpdateRequest { Target = entity });
}
}
if (requests.Any())
{
PerformUpdates(service, requests);
}
Trace("Data Migration Complete", count, total);
}
