public override void ExecuteExtention(BulkDeleteRequest request, BulkDeleteResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Deletions");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = record.Id;
RecordService.Delete(newRecord);
}
catch (Exception ex)
{
response.AddResponseItem(new BulkDeleteResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Deletions"));
}
}
public override void ExecuteExtention(BulkCopyFieldValueRequest request, BulkCopyFieldValueResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var reloadRecord = RecordService.Get(record.Type, record.Id, new[] { request.SourceField.Key, request.TargetField.Key });
if ((request.CopyIfNull || reloadRecord.GetField(request.SourceField.Key) != null) &&
(request.OverwriteIfPopulated || reloadRecord.GetField(request.TargetField.Key) == null))
{
reloadRecord.SetField(request.TargetField.Key, reloadRecord.GetField(request.SourceField.Key), RecordService);
RecordService.Update(reloadRecord, new[] { request.TargetField.Key });
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
}
response.Message = "Copies Completed";
}
public override void ExecuteExtention(BulkReplaceRequest request, BulkReplaceResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Replacements");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var recordWithFieldLoaded = RecordService.Get(request.RecordType.Key, record.Id);
var previousValue = recordWithFieldLoaded.GetStringField(request.FieldToReplaceIn.Key);
var newValue = previousValue == null ? null : previousValue.Replace(request.OldValue, request.NewValue);
if (previousValue != newValue)
{
recordWithFieldLoaded.SetField(request.FieldToReplaceIn.Key, newValue, RecordService);
RecordService.Update(recordWithFieldLoaded, new[] { request.FieldToReplaceIn.Key });
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Replacements"));
}
response.Message = "Replaces Completed";
}
public override void ExecuteExtention(BulkUpdateRequest request, BulkUpdateResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
foreach (var record in request.GetRecordsToUpdate())
{
try
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = record.Id;
if (request.ClearValue)
{
newRecord.SetField(request.FieldToSet.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet.Key, request.ValueToSet, RecordService);
}
RecordService.Update(newRecord, new[] { request.FieldToSet.Key });
}
catch (Exception ex)
{
response.AddResponseItem(new BulkUpdateResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
countUpdated++;
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
}
}
public override void ExecuteExtention(TestDialogRequest request, TestDialogResponse response,
ServiceRequestController controller)
{
if (request.ThrowFatalErrors)
{
throw new Exception("Nope " + "Nope ".ReplicateString(1000));
}
response.AddResponseItem(new TestDialogResponseItem("Dummy Response", null));
if (request.ThrowResponseErrors)
{
for (var i = 0; i < 100; i++)
{
response.AddResponseItem(new TestDialogResponseItem("Requested Error " + (i + 1),
new NotSupportedException("The Request Explicitly requested Errors",
new Exception("This Is The Inner Expection Text"))));
}
}
for (var i = 0; i < 100; i++)
{
controller.UpdateProgress(i, 100, "Fake Progress");
if (request.Wait10SecondsHalfwayThrough && i == 50)
{
Thread.Sleep(10000);
}
Thread.Sleep(10);
}
}
public override void ExecuteExtention(AddToSolutionRequest request, AddToSolutionResponse response,
ServiceRequestController controller)
{
var toDo = request.GetItemsToInclude().Count();
var done = 0;
foreach (var type in request.GetItemsToInclude())
{
try
{
controller.UpdateProgress(++done, toDo, $"Adding {XrmRecordService.GetPicklistLabel(Fields.solutioncomponent_.componenttype, Entities.solutioncomponent, type.ComponentTypeKey.ToString())} Components");
var theseItems = type.AddAllItems
? type.AllItems.Select(i => i.Id).ToArray()
: type.ItemsSelection.Where(i => i.Selected).Select(i => i.Id).ToArray();
XrmRecordService.AddSolutionComponents(request.SolutionAddTo.Id, type.ComponentTypeKey, theseItems);
}
catch (Exception ex)
{
response.AddResponseItem(new AddToSolutionResponseItem()
{
Exception = ex
});
}
}
}
public void ImportXml(string folder, ServiceRequestController controller,
ImportXmlResponse response, bool maskEmails = false, bool includeOwner = false, bool matchByName = true)
{
controller.UpdateProgress(0, 1, "Loading XML Files");
var entities = LoadEntitiesFromXmlFiles(folder, controller.Controller);
var matchOption = matchByName ? DataImportService.MatchOption.PrimaryKeyThenName : DataImportService.MatchOption.PrimaryKeyOnly;
var importResponse = DataImportService.DoImport(entities, controller, maskEmails, matchOption: matchOption, includeOwner: includeOwner);
response.LoadDataImport(importResponse);
}
public override void ExecuteExtention(CustomisationExporterRequest request,
CustomisationExporterResponse response,
ServiceRequestController controller)
{
response.Folder = request.SaveToFolder.FolderPath;
controller.LogLiteral("Loading Metadata");
ProcessForEntities(request, response, controller.Controller);
if ((request.Fields || request.FieldOptionSets) && request.IncludeAllRecordTypes)
{
controller.UpdateProgress(0, 1, "Loading All Fields.....");
Service.LoadFieldsForAllEntities();
}
if ((request.Fields || request.Relationships) && request.IncludeAllRecordTypes)
{
controller.UpdateProgress(0, 1, "Loading All Relationships.....");
Service.LoadRelationshipsForAllEntities();
}
ProcessForFields(request, response, controller.Controller);
ProcessForRelationships(request, response, controller.Controller);
ProcessForOptionSets(request, response, controller.Controller);
response.Folder = request.SaveToFolder.FolderPath;
if (request.Format == CustomisationExporterRequest.FileFormat.Xlsx)
{
var excelFileName = "Customisation Export " + DateTime.Now.ToFileTime() + ".xlsx";
ExcelUtility.CreateXlsx(request.SaveToFolder.FolderPath, excelFileName, response.GetListsToOutput());
response.ExcelFileName = excelFileName;
}
else
{
foreach (var item in response.GetListsToOutput())
{
var csvName = item.Key + " " + DateTime.Now.ToFileTime() + ".csv";
CsvUtility.CreateCsv(request.SaveToFolder.FolderPath, csvName, item.Value);
}
}
response.Message = "The Export is Complete";
}
public override void ExecuteExtention(TestGridEditRequest request, TestGridEditResponse response,
ServiceRequestController controller)
{
response.AddResponseItem(new TestGridEditResponseItem("Dummy Response", null));
for (var i = 0; i < 100; i++)
{
controller.UpdateProgress(i, 100, "Fake Progress");
Thread.Sleep(10);
}
}
public void ImportXml(IImportXmlRequest request, ServiceRequestController controller,
ImportXmlResponse response, bool maskEmails = false, bool includeOwner = false, bool matchByName = true, int?executeMultipleSetSize = null, int?targetCacheLimit = null)
{
controller.UpdateProgress(0, 1, "Loading XML Files");
var entities = request.GetOrLoadEntitiesForImport(controller.Controller).Values.ToArray();
var matchOption = matchByName ? MatchOption.PrimaryKeyThenName : MatchOption.PrimaryKeyOnly;
var importResponse = DataImportService.DoImport(entities, controller, maskEmails, matchOption: matchOption, includeOwner: includeOwner, executeMultipleSetSize: executeMultipleSetSize, targetCacheLimit: targetCacheLimit);
response.Connection = XrmRecordService.XrmRecordConfiguration;
response.LoadDataImport(importResponse);
response.Message = "The Import Process Has Completed";
}
public override void ExecuteExtention(TextSearchRequest request, TextSearchResponse response,
ServiceRequestController controller)
{
controller.UpdateProgress(0, 1, "Loading Text Search");
var document = DocumentWriter.NewDocument();
var firstSection = document.AddSection();
var nextSection = document.AddSection();
var container = new TextSearchContainer(request, response, controller.Controller, nextSection);
ProcessRecordsReferencingTheWord(container);
//insert title/summary
firstSection.AddTitle("Text Search");
var table = firstSection.Add2ColumnTable();
table.AddFieldToTable("Execution Time", DateTime.Now.ToString(StringFormats.DateTimeFormat));
table.AddFieldToTable("Search Operator", request.Operator.ToString());
table.AddFieldToTable("Search Terms", string.Join(", ", request.SearchTerms.Select(s => "\"" + s.Text + "\"")));
firstSection.AddTableOfContents(container.Bookmarks);
//save document
container.Controller.TurnOffLevel2();
container.Controller.UpdateProgress(1, 2, "Creating Document");
var folder = container.Request.SaveToFolder;
var fileName = string.Format("Record Extract - {0} - {1}", "TextSearch",
DateTime.Now.ToString("yyyyMMddHHmmss"));
if (container.Request.GenerateDocument)
{
fileName = document.Save(folder, fileName, container.Request.DocumentFormat);
container.Response.Folder = container.Request.SaveToFolder.FolderPath;
container.Response.FileName = fileName;
}
container.Response.GenerateSummaryItems(Service);
if (!container.Response.Summary.Any())
{
container.Response.Message = "No Matches Were Found For The Search Criteria";
}
}
public override void ExecuteExtention(RecordExtractRequest request, RecordExtractResponse response,
ServiceRequestController controller)
{
var document = DocumentWriter.NewDocument();
var firstSection = document.AddSection();
var nextSection = document.AddSection();
var extractToDocumentRequest = new RecordExtractToDocumentRequest(request.RecordLookup, nextSection,
controller.Controller, request.DetailOfRelatedRecords
, request.RecordTypesOnlyDisplayName.Where(r => r.RecordType != null).Select(r => r.RecordType.Key).ToArray()
, request.FieldsToExclude, request.RecordTypesToExclude.Where(r => r.RecordType != null).Select(r => r.RecordType.Key).ToArray()
, request.IncludeCreatedByAndOn, request.IncludeModifiedByAndOn, request.IncludeCrmOwner, request.IncludeState, request.IncludeStatus, request.StripHtmlTags, request.CustomHtmlFields);
var extractResponse = ExtractRecordToDocument(extractToDocumentRequest);
response.AddResponseItems(extractResponse.ResponseItems);
//insert title/summary
firstSection.AddTitle("Record Extract");
var table = firstSection.Add2ColumnTable();
table.AddFieldToTable("Execution Time", DateTime.Now.ToString(StringFormats.DateTimeFormat));
table.AddFieldToTable("Record Type", Service.GetDisplayName(request.RecordLookup.RecordType));
table.AddFieldToTable("Record Name",
extractResponse.Record.GetStringField(Service.GetPrimaryField(request.RecordLookup.RecordType)));
firstSection.AddTableOfContents(extractResponse.Bookmarks);
//save document
controller.UpdateProgress(1, 2, "Creating Document");
var folder = request.SaveToFolder;
var recordToExtractname =
extractResponse.Record.GetStringField(Service.GetPrimaryField(request.RecordLookup.RecordType));
var fileName = string.Format("Record Extract - {0} - {1}", recordToExtractname,
DateTime.Now.ToString("yyyyMMddHHmmss"));
fileName = document.Save(folder, fileName, request.DocumentFormat);
response.Folder = request.SaveToFolder.FolderPath;
response.FileName = fileName;
response.Message = "The Document Has Been Generated";
}
public override void ExecuteExtention(AddPortalCodeRequest request, AddPortalCodeResponse response,
ServiceRequestController controller)
{
var project = VisualStudioService.GetProject(request.ProjectName);
var exportConfigs = AddPortalCodeConfiguration.GetExportConfigs()
.Where(c => request.IncludeType(c.RecordType))
.ToArray();
var toDo = exportConfigs.Count();
var done = 0;
//okay so lets iterate the configurations
//and for each item not null add somehting to the vs solution
foreach (var config in exportConfigs)
{
controller.UpdateProgress(done++, toDo, "Exporting " + config.RecordType + " Code");
var results = AddPortalCodeConfiguration.GetRecordsForConfig(config.RecordType, Service, request.WebSite.Id);
results = request.FilterInclusionForType(config.RecordType, results);
var toDo2 = results.Count();
var done2 = 0;
foreach (var result in results)
{
++done2;
if (config.RecordType == Entities.adx_webfile)
{
controller.UpdateLevel2Progress(done2, toDo2, $"Processing {done2}/{toDo2}");
}
var recordName = result.GetStringField(Service.GetPrimaryField(config.RecordType));
var thisTypesFolderLabel = Service.GetDisplayName(config.RecordType);
var path = new List <string>();
if (request.CreateFolderForWebsiteName)
{
path.Add(request.WebSite.Name);
}
path.Add(thisTypesFolderLabel);
try
{
if (config.RecordType == Entities.adx_webfile)
{
var notes = Service.GetLinkedRecords(Entities.annotation, config.RecordType, Fields.annotation_.objectid, result.Id);
if (notes.Count() > 1)
{
throw new Exception("There is more than 1 note attached to the file. You will need to delete the excess notes to export");
}
else if (notes.Any() || request.ExportWhereFieldEmpty)
{
string fileContent = notes.Any()
? notes.First().GetStringField(Fields.annotation_.documentbody)
: null;
if (fileContent != null)
{
var data = Convert.FromBase64String(fileContent);
fileContent = Encoding.UTF8.GetString(data);
}
var fileName = recordName;
if (IncludeExtention(request, fileName))
{
project.AddItem(fileName, fileContent, path.ToArray());
}
}
}
else
{
foreach (var field in config.FieldsToExport)
{
var content = result.GetStringField(field.FieldName);
if (content != null || request.ExportWhereFieldEmpty)
{
var fileExtention = field.Extention;
var fileName = recordName + "." + fileExtention;
//https://superuser.com/questions/187469/how-would-i-go-about-creating-a-filename-with-invalid-characters-such-as
// / -you can use a division symbol ∕
// : -you can use the modifier letter colon ꞉
fileName = fileName?.Replace("/", "∕");
fileName = fileName?.Replace(":", "꞉");
if (IncludeExtention(request, fileName))
{
project.AddItem(fileName, content, path.ToArray());
}
}
}
}
}
catch (Exception ex)
{
response.AddResponseItem(new AddPortalCodeResponseItem()
{
RecordType = config.RecordType, RecordName = recordName, Exception = ex
});
}
}
controller.TurnOffLevel2();
}
response.Message = "Export Completed";
}
public override void ExecuteExtention(DeployWebResourceRequest request, DeployWebResourceResponse response,
ServiceRequestController controller)
{
var records = new List <IRecord>();
var publishIds = new List <string>();
var totalTasks = request.Files.Count() + 1;
var tasksCompleted = 0;
foreach (var file in request.Files)
{
var fileInfo = new FileInfo(file);
var fileName = fileInfo.Name;
controller.UpdateProgress(++tasksCompleted, totalTasks, "Deploying " + fileName);
var responseItem = new DeployWebResourceResponseItem();
responseItem.Name = fileName;
response.AddResponseItem(responseItem);
try
{
var content = File.ReadAllBytes(file);
var contentString = Convert.ToBase64String(content);
//okay lets allow match on either name or display name
var match = Service.GetFirst(Entities.webresource, Fields.webresource_.name, fileName);
if (match == null)
{
match = Service.GetFirst(Entities.webresource, Fields.webresource_.displayname, fileName);
}
if (match != null)
{
if (match.GetStringField(Fields.webresource_.content) != contentString)
{
match.SetField(Fields.webresource_.content, contentString, Service);
Service.Update(match, new[] { Fields.webresource_.content });
publishIds.Add(match.Id);
responseItem.Updated = true;
}
}
else
{
var record = Service.NewRecord(Entities.webresource);
record.SetField(Fields.webresource_.name, fileInfo.Name, Service);
record.SetField(Fields.webresource_.displayname, fileInfo.Name, Service);
record.SetField(Fields.webresource_.content, Convert.ToBase64String(content), Service);
record.SetField(Fields.webresource_.webresourcetype, GetWebResourceType(fileInfo.Extension), Service);
record.Id = Service.Create(record);
publishIds.Add(record.Id);
responseItem.Created = true;
}
}
catch (Exception ex)
{
responseItem.Exception = ex;
}
}
if (publishIds.Any())
{
controller.UpdateProgress(totalTasks, totalTasks, "Publishing Files");
var xml = new StringBuilder();
xml.Append("<importexportxml><webresources>");
foreach (var id in publishIds)
{
xml.Append("<webresource>" + id + "</webresource>");
}
xml.Append("</webresources></importexportxml>");
Service.Publish(xml.ToString());
}
//add plugin assembly to the solution
var componentType = OptionSets.SolutionComponent.ObjectTypeCode.WebResource;
if (PackageSettings.AddToSolution)
{
Service.AddSolutionComponents(PackageSettings.Solution.Id, componentType, publishIds);
}
}
public override void ExecuteExtention(BulkWorkflowRequest request, BulkWorkflowResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Workflows");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (thisSetOfRecords.Count() == 1)
{
var record = thisSetOfRecords.First();
try
{
RecordService.XrmService.Execute(new ExecuteWorkflowRequest
{
EntityId = new Guid(record.Id),
WorkflowId = new Guid(request.Workflow.Id)
});
}
catch (Exception ex)
{
response.AddResponseItem(new BulkWorkflowResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
errorsThisIteration++;
}
}
else
{
var requests = thisSetOfRecords.Select(r => new ExecuteWorkflowRequest
{
EntityId = new Guid(r.Id),
WorkflowId = new Guid(request.Workflow.Id)
});
var multipleResponse = RecordService.XrmService.ExecuteMultiple(requests);
var key = 0;
foreach (var item in multipleResponse)
{
var originalRecord = thisSetOfRecords[key];
if (item.Fault != null)
{
response.AddResponseItem(new BulkWorkflowResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), new FaultException <OrganizationServiceFault>(item.Fault, item.Fault.Message)));
errorsThisIteration++;
}
key++;
}
}
countUpdated += thisSetOfRecords.Count();
response.NumberOfErrors += errorsThisIteration;
response.TotalRecordsProcessed = countUpdated;
Thread.Sleep(request.WaitPerMessage * 1000);
}
controller.UpdateProgress(1, 1, "All Workflows Requests Have Completed");
response.Message = "Workflows Requests Completed";
}
public override void ExecuteExtention(BulkReplaceRequest request, BulkReplaceResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Replacements");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Replacements"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = RecordService.GetMultiple(thisSetOfRecords.First().Type,
thisSetOfRecords.Select(r => r.Id),
request.FieldsToReplace.Select(f => f.RecordField.Key).ToArray())
.ToArray();
var errorsThisIteration = 0;
var recordsToUpdate = new List <IRecord>();
foreach (var record in thisSetOfRecordsNew)
{
try
{
var newRecord = RecordService.NewRecord(record.Type);
newRecord.Id = record.Id;
var isUpdate = false;
foreach (var field in request.FieldsToReplace)
{
var previousValue = record.GetStringField(field.RecordField.Key);
var newValue = previousValue;
foreach (var replacement in request.ReplacementTexts)
{
newValue = newValue == null ? null : newValue.Replace(replacement.OldText, replacement.NewText);
}
if (previousValue != newValue)
{
newRecord.SetField(field.RecordField.Key, newValue, RecordService);
isUpdate = true;
}
}
if (isUpdate)
{
recordsToUpdate.Add(newRecord);
}
}
catch (Exception ex)
{
errorsThisIteration++;
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
//old versions dont have execute multiple so if 1 then do each request
if (recordsToUpdate.Count() == 1)
{
var record = recordsToUpdate.First();
try
{
RecordService.Update(record);
}
catch (Exception ex)
{
errorsThisIteration++;
response.AddResponseItem(new BulkReplaceResponseItem(record.Id, null, ex));
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(recordsToUpdate);
foreach (var item in multipleResponse)
{
var originalRecord = recordsToUpdate[item.Key];
response.AddResponseItem(new BulkReplaceResponseItem(originalRecord.Id, null, item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.TotalRecordsProcessed = countUpdated;
response.TotalRecordsUpdated += recordsToUpdate.Count();
response.NumberOfErrors += errorsThisIteration;
}
controller.UpdateProgress(1, 1, "Replaces Completed");
response.Message = "Replaces Completed";
}
private void CreateDeploymentPackage(CreatePackageRequest request, ServiceRequestController controller, CreatePackageResponse response)
{
var folderPath = request.FolderPath.FolderPath;
var tasksDone = 0;
var totalTasks = 4;
var xrmRecordService = XrmRecordService;
var service = xrmRecordService.XrmService;
var solution = service.Retrieve(Entities.solution, new Guid(request.Solution.Id));
tasksDone++;
if (solution.GetStringField(Fields.solution_.version) != request.ThisReleaseVersion)
{
controller.UpdateProgress(tasksDone, totalTasks, "Setting Release Version " + request.ThisReleaseVersion);
solution.SetField(Fields.solution_.version, request.ThisReleaseVersion);
service.Update(solution, new[] { Fields.solution_.version });
}
controller.UpdateProgress(tasksDone, totalTasks, "Exporting Solution " + request.Solution.Name);
var uniqueName = (string)solution.GetStringField(Fields.solution_.uniquename);
var req = new ExportSolutionRequest();
req.Managed = request.ExportAsManaged;
req.SolutionName = uniqueName;
var exportResponse = (ExportSolutionResponse)service.Execute(req);
var version = solution.GetStringField(Fields.solution_.version);
var versionText = version == null ? null : version.Replace(".", "_");
var fileName = string.Format("{0}_{1}{2}.zip", uniqueName, versionText,
request.ExportAsManaged ? "_managed" : null);
FileUtility.WriteToFile(folderPath, fileName, exportResponse.ExportSolutionFile);
++tasksDone;
if (request.DataToInclude != null && request.DataToInclude.Any())
{
controller.UpdateProgress(tasksDone, totalTasks, "Exporting Data " + request.Solution.Name);
var dataExportService = new ExportXmlService(xrmRecordService);
dataExportService.ExportXml(request.DataToInclude,
new Folder(GetDataExportFolder(folderPath)), request.IncludeNotes,
request.IncludeNNRelationshipsBetweenEntities, controller.Controller);
}
tasksDone++;
if (solution.GetStringField(Fields.solution_.version) != request.SetVersionPostRelease)
{
controller.UpdateProgress(tasksDone, totalTasks, "Setting New Solution Version " + request.SetVersionPostRelease);
solution.SetField(Fields.solution_.version, request.SetVersionPostRelease);
service.Update(solution, new[] { Fields.solution_.version });
}
if (request.DeployPackageInto != null)
{
if (response.HasError)
{
throw new Exception("Package Deployment Aborted Due To Errors During Creating");
}
else
{
var deployRequest = new DeployPackageRequest
{
FolderContainingPackage = request.FolderPath,
Connection = request.DeployPackageInto
};
var deployService = new DeployPackageService();
var deployPackageResponse = new DeployPackageResponse();
deployService.ExecuteExtention(deployRequest, deployPackageResponse, controller);
response.LoadDeployPackageResponse(deployPackageResponse);
}
}
}
public override void ExecuteExtention(BulkUpdateRequest request, BulkUpdateResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = thisSetOfRecords
.Select(r =>
{
var newRecord = RecordService.NewRecord(request.RecordType.Key);
newRecord.Id = r.Id;
if (request.ClearValue)
{
newRecord.SetField(request.FieldToSet.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet.Key, request.ValueToSet, RecordService);
}
if (request.AddUpdateField2)
{
if (request.ClearValue2)
{
newRecord.SetField(request.FieldToSet2.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet2.Key, request.ValueToSet2, RecordService);
}
}
if (request.AddUpdateField3)
{
if (request.ClearValue3)
{
newRecord.SetField(request.FieldToSet3.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet3.Key, request.ValueToSet3, RecordService);
}
}
if (request.AddUpdateField4)
{
if (request.ClearValue4)
{
newRecord.SetField(request.FieldToSet4.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet4.Key, request.ValueToSet4, RecordService);
}
}
if (request.AddUpdateField5)
{
if (request.ClearValue5)
{
newRecord.SetField(request.FieldToSet5.Key, null, RecordService);
}
else
{
newRecord.SetField(request.FieldToSet5.Key, request.ValueToSet5, RecordService);
}
}
return(newRecord);
})
.ToArray();
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (thisSetOfRecordsNew.Count() == 1)
{
var record = thisSetOfRecordsNew.First();
try
{
RecordService.Update(record);
}
catch (Exception ex)
{
response.AddResponseItem(new BulkUpdateResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
errorsThisIteration++;
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(thisSetOfRecordsNew);
foreach (var item in multipleResponse)
{
var originalRecord = thisSetOfRecords[item.Key];
response.AddResponseItem(new BulkUpdateResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.NumberOfErrors += errorsThisIteration;
response.TotalRecordsProcessed = countUpdated;
}
controller.UpdateProgress(1, 1, "Updates Completed");
response.Message = "Updates Completed";
}
public override void ExecuteExtention(ManagePluginTriggersRequest request, ManagePluginTriggersResponse response, ServiceRequestController controller)
{
controller.UpdateProgress(0, 4, "Processing Deletions");
//delete any removed plugins
var removedPlugins = request.GetSdkMessageStepsPre().Where(smsp => request.Triggers.All(pt => pt.Id != smsp.Id)).ToArray();
var deletions = Service.DeleteInCrm(removedPlugins);
response.AddResponseItems(deletions.Errors.Select(e => new ManagePluginTriggersResponseItem("Event Delete", e.Key.GetStringField(Fields.sdkmessageprocessingstep_.name), e.Value)));
response.AddResponseItems(deletions.Deleted.Select(d => new ManagePluginTriggersResponseItem("Event Delete", d.GetStringField(Fields.sdkmessageprocessingstep_.name))));
//load the filter entities which exist for each entity type, message combination
var filters = request.Triggers.Select(t =>
{
var filter = new Filter();
filter.AddCondition(Fields.sdkmessagefilter_.primaryobjecttypecode, ConditionType.Equal, t.RecordType == null ? "none" : t.RecordType.Key);
filter.AddCondition(Fields.sdkmessagefilter_.sdkmessageid, ConditionType.Equal, t.Message.Id);
return(filter);
}).ToArray();
var pluginFilters = Service.RetrieveAllOrClauses(Entities.sdkmessagefilter, filters);
controller.UpdateProgress(1, 4, "Unloading Triggers");
//unload the triggers into an entity object referencing it in a dictionary
var unloadedObjects = new Dictionary <IRecord, PluginTrigger>();
foreach (var item in request.Triggers)
{
var matchingPluginFilters =
pluginFilters.Where(f => f.GetLookupId(Fields.sdkmessagefilter_.sdkmessageid) == item.Message.Id
&&
((item.RecordType == null && f.GetStringField(Fields.sdkmessagefilter_.primaryobjecttypecode) == "none")
||
(item.RecordType != null && f.GetStringField(Fields.sdkmessagefilter_.primaryobjecttypecode) == item.RecordType.Key)))
.ToArray();
var record = Service.NewRecord(Entities.sdkmessageprocessingstep);
var name = string.Format("{0} {1} {2} {3} {4}", item.Plugin, item.RecordType?.Key ?? "none", item.Message, item.Stage, item.Mode).Left(Service.GetMaxLength(Fields.sdkmessageprocessingstep_.name, Entities.sdkmessageprocessingstep));
try
{
if (!matchingPluginFilters.Any())
{
response.AddResponseItem(new ManagePluginTriggersResponseItem("Warning", name, new NullReferenceException($"No Matching {Service.GetDisplayName(Entities.sdkmessagefilter)} Could Be Found For The Trigger Configuration")));
}
record.SetField(Fields.sdkmessageprocessingstep_.name, name, Service);
record.SetField(Fields.sdkmessageprocessingstep_.rank, item.Rank, Service);
if (item.Stage != null)
{
record.SetField(Fields.sdkmessageprocessingstep_.stage, (int)item.Stage, Service);
}
if (item.Mode != null)
{
record.SetField(Fields.sdkmessageprocessingstep_.mode, (int)item.Mode, Service);
}
record.SetField(Fields.sdkmessageprocessingstep_.plugintypeid, item.Plugin, Service);
record.SetField(Fields.sdkmessageprocessingstep_.sdkmessagefilterid, !matchingPluginFilters.Any() ? null : matchingPluginFilters.First().ToLookup(), Service);
record.SetField(Fields.sdkmessageprocessingstep_.sdkmessageid, item.Message, Service);
record.SetField(Fields.sdkmessageprocessingstep_.impersonatinguserid, item.SpecificUserContext == null || item.SpecificUserContext.Id == null ? null : item.SpecificUserContext, Service);
if (item.Id != null)
{
record.SetField(Fields.sdkmessageprocessingstep_.sdkmessageprocessingstepid, item.Id, Service);
}
record.SetField(Fields.sdkmessageprocessingstep_.asyncautodelete, item.Mode == PluginTrigger.PluginMode.Asynch, Service);
record.SetField(Fields.sdkmessageprocessingstep_.filteringattributes, item.FilteringFields != null && item.FilteringFields.Any() ? string.Join(",", item.FilteringFields.OrderBy(r => r.Key).Select(r => r.Key)) : null, Service);
unloadedObjects.Add(record, item);
}
catch (Exception ex)
{
response.AddResponseItem(new ManagePluginTriggersResponseItem("Unload Error", name, ex));
}
}
controller.UpdateProgress(2, 4, "Creating/Updating Triggers");
//submit them to crm create/update
var triggerLoads = Service.LoadIntoCrm(unloadedObjects.Keys,
Fields.sdkmessageprocessingstep_.sdkmessageprocessingstepid);
foreach (var e in triggerLoads.Errors)
{
response.AddResponseItem(new ManagePluginTriggersResponseItem(e.Key.Id != null ? "Event Update" : "Event Create", e.Key.GetStringField(Fields.sdkmessageprocessingstep_.name), e.Value));
}
response.AddResponseItems(triggerLoads.Created.Select(d => new ManagePluginTriggersResponseItem("Event Create", d.GetStringField(Fields.sdkmessageprocessingstep_.name))));
response.AddResponseItems(triggerLoads.Updated.Select(d => new ManagePluginTriggersResponseItem("Event Update", d.GetStringField(Fields.sdkmessageprocessingstep_.name))));
controller.UpdateProgress(3, 4, "Creating/Updating Images");
var updatesAndDeletes =
unloadedObjects.Keys.Where(
r =>
new[] { "Update", "Delete" }.Contains(
r.GetLookupName(Fields.sdkmessageprocessingstep_.sdkmessageid)))
.ToArray();
var solutionItemsToAdd = new List <string>();
//update/delete pre-images
var imagesToCreateOrUpdate = new List <IRecord>();
var imagesToDelete = new List <IRecord>();
foreach (var item in updatesAndDeletes
.Where(i => !triggerLoads.Errors.Keys.Contains(i)))
{
var matchingPluginTrigger = unloadedObjects[item];
//the plugin will only have an image if all fields, or there are specific fields selected
var hasImage = matchingPluginTrigger.PreImageAllFields || (matchingPluginTrigger.PreImageFields != null && matchingPluginTrigger.PreImageFields.Any());
if (!hasImage)
{
//delete the existing image if is has been changed to not have an image
if (matchingPluginTrigger.PreImageId != null)
{
try
{
imagesToDelete.Add(Service.Get(Entities.sdkmessageprocessingstepimage, matchingPluginTrigger.PreImageId));
solutionItemsToAdd.Add(matchingPluginTrigger.Id);
}
catch (Exception ex)
{
response.AddResponseItem(new ManagePluginTriggersResponseItem("Pre Image Delete", matchingPluginTrigger.Id, ex));
}
}
}
else
{
try
{
//set the details to create/update in the pre-image
var isUpdate = triggerLoads.Updated.Contains(item);
var imageRecord = Service.NewRecord(Entities.sdkmessageprocessingstepimage);
imageRecord.Id = matchingPluginTrigger.PreImageId;
if (matchingPluginTrigger.PreImageId != null)
{
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepimageid, matchingPluginTrigger.PreImageId, Service);
}
if (matchingPluginTrigger.PreImageIdUnique != null)
{
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepimageidunique, matchingPluginTrigger.PreImageIdUnique, Service);
}
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.name, matchingPluginTrigger.PreImageName, Service);
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.entityalias, matchingPluginTrigger.PreImageName, Service);
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.messagepropertyname, "Target", Service);
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid, Service.ToLookup(item), Service);
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.imagetype, OptionSets.SdkMessageProcessingStepImage.ImageType.PreImage, Service);
var attributesString = matchingPluginTrigger.PreImageAllFields || matchingPluginTrigger.PreImageFields == null || !matchingPluginTrigger.PreImageFields.Any()
? null
: string.Join(",", matchingPluginTrigger.PreImageFields.Select(f => f.Key).OrderBy(s => s).ToArray());
imageRecord.SetField(Fields.sdkmessageprocessingstepimage_.attributes, attributesString, Service);
imagesToCreateOrUpdate.Add(imageRecord);
}
catch (Exception ex)
{
response.AddResponseItem(new ManagePluginTriggersResponseItem("Image Error", item.GetStringField(Fields.sdkmessageprocessingstep_.name), ex));
}
}
}
//submit create/update/deletion of pre-images
var imageLoads = Service.LoadIntoCrm(imagesToCreateOrUpdate,
Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepimageidunique);
foreach (var e in imageLoads.Errors)
{
response.AddResponseItem(new ManagePluginTriggersResponseItem(e.Key.Id != null ? "Pre Image Update" : "Pre Image Create", e.Key.GetLookupName(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid), e.Value));
}
response.AddResponseItems(imageLoads.Created.Select(d => new ManagePluginTriggersResponseItem("Pre Image Create", d.GetLookupName(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid))));
response.AddResponseItems(imageLoads.Updated.Select(d => new ManagePluginTriggersResponseItem("Pre Image Update", d.GetLookupName(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid))));
var imageDeletions = Service.DeleteInCrm(imagesToDelete);
response.AddResponseItems(imageDeletions.Errors.Select(e => new ManagePluginTriggersResponseItem("Pre Image Delete", e.Key.GetLookupName(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid), e.Value)));
//add plugin steps to the solution
var componentType = OptionSets.SolutionComponent.ObjectTypeCode.SDKMessageProcessingStep;
solutionItemsToAdd.AddRange(triggerLoads.Created.Union(triggerLoads.Updated).Select(r => r.Id).ToList());
var imagesReferences = imageLoads.Created.Union(imageLoads.Updated)
.Select(i => i.GetLookupId(Fields.sdkmessageprocessingstepimage_.sdkmessageprocessingstepid))
.Where(id => !string.IsNullOrWhiteSpace(id));
solutionItemsToAdd.AddRange(imagesReferences);
if (PackageSettings.AddToSolution)
{
controller.UpdateProgress(4, 4, "Adding Components To Solution");
Service.AddSolutionComponents(PackageSettings.Solution.Id, componentType, solutionItemsToAdd);
}
if (response.HasResponseItemError)
{
response.Message = "There Were Errors Thrown Updating The Plugins";
}
else if (!response.HasResponseItems)
{
response.Message = "No Updates Were Identified";
}
else
{
response.Message = "Plugins Updated";
}
}
public override void ExecuteExtention(ConfigureAutonumberRequest request, ConfigureAutonumberResponse response,
ServiceRequestController controller)
{
controller.UpdateProgress(0, 5, "Processing Field Update");
//okay we need to update the autonumber
var fieldName = request.Field?.Key;
var recordType = request.RecordType?.Key;
var xrmService = XrmRecordService.XrmService;
controller.UpdateProgress(1, 5, "Loading Field metadata");
var stringFieldMetadata = xrmService.GetFieldMetadata(fieldName, recordType) as StringAttributeMetadata;
if (stringFieldMetadata == null)
{
throw new Exception($"Field {fieldName} In {recordType} Is Not Of Type {nameof(StringAttributeMetadata)}");
}
//apparently if null doesnt apply the clear so lets set as empty string if null
request.AutonumberFormat = request.AutonumberFormat ?? string.Empty;
if (stringFieldMetadata.AutoNumberFormat != request.AutonumberFormat)
{
//okay I have noted that the autonumber does not seem to always apply immediatelly
//that is when querying the metadata after setting the autonumber config
//sometimes it does not return the applied value
//so lets do wait/retry
var numberOfSecondsToCheckUpdated = 4;
var retryAfterNumberOfChecks = 3;
var numberOfRetriesLeft = 3;
var isUpdated = false;
while (true)
{
controller.UpdateProgress(2, 5, "Setting Format");
stringFieldMetadata.AutoNumberFormat = request.AutonumberFormat;
xrmService.CreateOrUpdateAttribute(fieldName, recordType, stringFieldMetadata);
controller.UpdateProgress(3, 5, "Publishing");
var publishXml = $"<importexportxml><entities><entity>{recordType}</entity></entities></importexportxml>";
xrmService.Publish(publishXml);
for (var i = 0; i < retryAfterNumberOfChecks; i++)
{
var getAttributeResponse = (RetrieveAttributeResponse)xrmService.Execute(new RetrieveAttributeRequest()
{
EntityLogicalName = request.RecordType.Key,
LogicalName = request.Field.Key
});
var stringAttributeMetadata = getAttributeResponse.AttributeMetadata as StringAttributeMetadata;
if (stringAttributeMetadata.AutoNumberFormat == request.AutonumberFormat)
{
isUpdated = true;
response.FormatUpdated = true;
xrmService.SetFieldMetadataCache(request.RecordType.Key, request.Field.Key, stringAttributeMetadata);
break;
}
Thread.Sleep(numberOfSecondsToCheckUpdated * 1000);
}
if (isUpdated)
{
break;
}
numberOfRetriesLeft--;
if (numberOfRetriesLeft == 0)
{
throw new Exception("The Autonumber Configuration May Not be Applied. The New Format Was Sent To The Web Service Several Times But Dynamics Has Not Applied The Settings According To The Metadata Provided By The Web Service. Perhaps Retry");
}
}
}
if (request.SetSeed.HasValue)
{
controller.UpdateProgress(4, 5, "Updating Seed Field Update");
var req = new SetAutoNumberSeedRequest
{
AttributeName = fieldName,
EntityName = recordType,
Value = request.SetSeed.Value
};
xrmService.Execute(req);
response.SeedUpdated = true;
}
controller.UpdateProgress(5, 5, "Finishing");
}
public override void ExecuteExtention(RecordCountsRequest request,
RecordCountsResponse response,
ServiceRequestController controller)
{
controller.LogLiteral("Loading Types");
var excludeTheseTypes = new[] { Entities.msdyn_componentlayer, Entities.msdyn_solutioncomponentsummary, Entities.msdyn_nonrelationalds, Entities.datalakeworkspace, Entities.datalakeworkspacepermission };
var recordTypes = request.AllRecordTypes
? Service.GetAllRecordTypes()
.Except(excludeTheseTypes)
.Where(r => Service.GetRecordTypeMetadata(r).Searchable)
.OrderBy(n => Service.GetDisplayName(n))
.ToArray()
: request.RecordTypes.Select(p => p.RecordType.Key).ToArray();
if (request.OnlyIncludeSelectedOwner)
{
recordTypes = recordTypes.Where(r => Service.GetRecordTypeMetadata(r).HasOwner).ToArray();
}
var numberOfTypes = recordTypes.Count();
var numberOfTypesCompleted = 0;
var noOwnerIndex = "Organisation";
var recordCountsByUser = new Dictionary <string, Dictionary <string, long> >();
//due to limitations in crm web service cannot do a standard aggregate
//as they are limitied to 50K records OOTB
//need to query all records and manually aggregate
foreach (var recordType in recordTypes)
{
var thisDictionary = new Dictionary <string, long>();
try
{
var metadata = Service.GetRecordTypeMetadata(recordType);
var hasOwner = metadata.HasOwner;
if (!hasOwner)
{
thisDictionary.Add(noOwnerIndex, 0);
}
long totalThisIteration = 0;
var func = hasOwner
? ((records) =>
{
totalThisIteration += records.Count();
controller.UpdateProgress(numberOfTypesCompleted, numberOfTypes, string.Format("Counting {0} ({1})", recordType, totalThisIteration));
foreach (var record in records)
{
var ownerType = record.GetLookupType("ownerid");
var ownerId = record.GetLookupId("ownerid");
var format = string.Format("{0}:{1}", ownerType, ownerId);
if (!thisDictionary.ContainsKey(format))
{
thisDictionary.Add(format, 0);
}
thisDictionary[format]++;
}
})
: (Action <IEnumerable <IRecord> >)((records) =>
{
totalThisIteration += records.Count();
controller.UpdateProgress(numberOfTypesCompleted, numberOfTypes, string.Format("Counting {0} ({1})", recordType, totalThisIteration));
foreach (var record in records)
{
thisDictionary[noOwnerIndex]++;
}
});
var fields = hasOwner
? new[] { "ownerid" }
: new string[0];
var conditions = request.OnlyIncludeSelectedOwner
? new[] { new Condition("ownerid", ConditionType.Equal, request.Owner.Id) }
: new Condition[0];
var query = new QueryDefinition(recordType);
var filter = new Filter();
filter.Conditions.AddRange(conditions);
query.RootFilter.SubFilters.Add(filter);
query.Fields = fields;
Service.ProcessResults(query, func);
recordCountsByUser.Add(recordType, thisDictionary);
}
catch (Exception ex)
{
response.AddResponseItem(new RecordCountsResponseItem(recordType, "Error Generating Counts", ex));
}
finally
{
numberOfTypesCompleted++;
}
}
controller.LogLiteral("Generating CSV files");
var groupByOwner = request.GroupCountsByOwner ||
request.OnlyIncludeSelectedOwner;
if (!groupByOwner)
{
var totals = new List <RecordCount>();
foreach (var dictionary in recordCountsByUser)
{
totals.Add(new RecordCount(Service.GetDisplayName(dictionary.Key), dictionary.Value.Sum(kv => kv.Value)));
}
response.RecordCounts = totals;
}
if (groupByOwner)
{
var teamNameField = Service.GetRecordTypeMetadata(Entities.team).PrimaryFieldSchemaName;
var userNameField = Service.GetRecordTypeMetadata(Entities.systemuser).PrimaryFieldSchemaName;
var allDistinctOwners = recordCountsByUser
.SelectMany(kv => kv.Value.Select(kv2 => kv2.Key))
.Distinct();
var allTeams = allDistinctOwners
.Where(s => s.StartsWith(Entities.team))
.Distinct();
var allUsers = allDistinctOwners
.Where(s => s.StartsWith(Entities.systemuser))
.Distinct();
var ownerKeyLabels = new Dictionary <string, string>();
var teams = Service.RetrieveAll(Entities.team, new[] { teamNameField });
foreach (var team in teams)
{
ownerKeyLabels.Add(string.Format("{0}:{1}", Entities.team, team.Id), team.GetStringField(teamNameField));
}
var users = Service.RetrieveAll(Entities.systemuser, null);
foreach (var user in users)
{
ownerKeyLabels.Add(string.Format("{0}:{1}", Entities.systemuser, user.Id), user.GetStringField(userNameField));
}
var ownerTotals = new List <RecordCountByOwner>();
foreach (var dictionary in recordCountsByUser)
{
foreach (var owner in dictionary.Value)
{
if (owner.Key == noOwnerIndex)
{
ownerTotals.Add(new RecordCountByOwner(Service.GetDisplayName(dictionary.Key), owner.Value, noOwnerIndex, noOwnerIndex));
}
else
{
if (ownerKeyLabels.ContainsKey(owner.Key))
{
ownerTotals.Add(new RecordCountByOwner(Service.GetDisplayName(dictionary.Key), owner.Value, Service.GetDisplayName(owner.Key.Split(':')[0]), ownerKeyLabels[owner.Key]));
}
else
{
ownerTotals.Add(new RecordCountByOwner(Service.GetDisplayName(dictionary.Key), owner.Value, "Unknown", "Unknown"));
}
}
}
}
response.RecordCounts = ownerTotals;
}
}
public override void ExecuteExtention(BulkCopyFieldValueRequest request, BulkCopyFieldValueResponse response,
ServiceRequestController controller)
{
var countToUpdate = request.RecordCount;
var countUpdated = 0;
controller.UpdateProgress(0, countToUpdate, "Executing Updates");
var estimator = new TaskEstimator(countToUpdate);
var recordsRemaining = request.GetRecordsToUpdate().ToList();
while (recordsRemaining.Any())
{
controller.UpdateProgress(countUpdated, countToUpdate, estimator.GetProgressString(countUpdated, taskName: "Executing Updates"));
var thisSetOfRecords = recordsRemaining
.Take(request.ExecuteMultipleSetSize ?? 50)
.ToList();
recordsRemaining.RemoveRange(0, thisSetOfRecords.Count);
var thisSetOfRecordsNew = RecordService.GetMultiple(thisSetOfRecords.First().Type,
thisSetOfRecords.Select(r => r.Id),
new[] { request.SourceField.Key, request.TargetField.Key })
.ToArray();
var recordsToUpdate = new List <IRecord>();
foreach (var record in thisSetOfRecordsNew)
{
try
{
var sourceValue = record.GetField(request.SourceField.Key);
var targetValue = record.GetField(request.TargetField.Key);
var parseSourceintoTarget = RecordService.ParseField(request.SourceField.Key, record.Type, sourceValue);
if (!record.FieldsEqual(request.TargetField.Key, parseSourceintoTarget))
{
if ((request.CopyIfNull || sourceValue != null) &&
(request.OverwriteIfPopulated || targetValue == null))
{
record.SetField(request.TargetField.Key, parseSourceintoTarget, RecordService);
recordsToUpdate.Add(record);
}
}
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
var errorsThisIteration = 0;
//old versions dont have execute multiple so if 1 then do each request
if (recordsToUpdate.Count() == 1)
{
var record = recordsToUpdate.First();
try
{
RecordService.Update(record, new[] { request.TargetField.Key });
}
catch (Exception ex)
{
response.AddResponseItem(new BulkCopyFieldValueResponseItem(record.Id, record.GetStringField(RecordService.GetPrimaryField(record.Type)), ex));
}
}
else
{
var multipleResponse = RecordService.UpdateMultiple(recordsToUpdate, new[] { request.TargetField.Key });
foreach (var item in multipleResponse)
{
var originalRecord = recordsToUpdate[item.Key];
response.AddResponseItem(new BulkCopyFieldValueResponseItem(originalRecord.Id, originalRecord.GetStringField(RecordService.GetPrimaryField(originalRecord.Type)), item.Value));
}
errorsThisIteration += multipleResponse.Count;
}
countUpdated += thisSetOfRecords.Count();
response.TotalRecordsProcessed = countUpdated;
response.TotalRecordsUpdated += recordsToUpdate.Count();
response.NumberOfErrors += errorsThisIteration;
}
controller.UpdateProgress(1, 1, "Copies Completed");
response.Message = "Copies Completed";
}
public override void ExecuteExtention(DeployIntoFieldRequest request, DeployIntoFieldResponse response,
ServiceRequestController controller)
{
var records = new List <IRecord>();
var publishIds = new List <string>();
var numberToDo = request.Files.Count();
var numberDone = 0;
foreach (var file in request.Files.Select(f => f?.Replace("∕", "∕")))
{
var fileInfo = new FileInfo(file);
controller.UpdateProgress(++numberDone, numberToDo, "Importing " + fileInfo.Name);
var thisResponseItem = new DeployIntoFieldResponseItem()
{
Name = fileInfo.Name
};
response.AddResponseItem(thisResponseItem);
try
{
var containingFolderName = fileInfo.Directory.Name;
var containingFolderParentName = fileInfo.Directory.Parent != null
? fileInfo.Directory.Parent.Name
: null;
//get target record type
string recordType = null;
if (Service.GetAllRecordTypes().Any(r => r == containingFolderName))
{
recordType = Service.GetAllRecordTypes().First(r => r == containingFolderName);
}
else if (Service.GetAllRecordTypes().Any(r => Service.GetDisplayName(r)?.ToLower() == containingFolderName.ToLower()))
{
recordType = Service.GetAllRecordTypes().First(r => Service.GetDisplayName(r)?.ToLower() == containingFolderName.ToLower());
}
else
{
throw new NullReferenceException($"Could not find matching type by logical or display name for folder name of {containingFolderName}");
}
thisResponseItem.RecordType = recordType;
if (recordType == Entities.adx_webfile)
{
//this one goes into an attachment
var matchingRecord = GetRecordToDeployInto(recordType, fileInfo.Name, containingFolderParentName);
if (matchingRecord == null)
{
throw new NullReferenceException($"There is no {Service.GetDisplayName(recordType)} record name {fileInfo.Name} to load the file attachment into");
}
thisResponseItem.Link = new Url(Service.GetWebUrl(matchingRecord.Type, matchingRecord.Id), "Open");
//get matching attachment by name else create a new one
var fileAttachments = Service.RetrieveAllAndClauses(Entities.annotation, new[]
{
new Condition(Fields.annotation_.filename, ConditionType.Equal, fileInfo.Name),
new Condition(Fields.annotation_.objectid, ConditionType.Equal, matchingRecord.Id)
}).OrderBy(n => n.GetDateTime(Fields.annotation_.createdon)).ToArray();
var contentBytes = File.ReadAllBytes(file);
var contentBase64String = Convert.ToBase64String(contentBytes);
if (fileAttachments.Any())
{
//lets update the last modifed one
var attachmentToUpdate = fileAttachments.First();
if (attachmentToUpdate.GetStringField(Fields.annotation_.documentbody) != contentBase64String)
{
attachmentToUpdate.SetField(Fields.annotation_.documentbody, contentBase64String, Service);
Service.Update(attachmentToUpdate, new[] { Fields.annotation_.documentbody });
thisResponseItem.Updated = true;
}
}
else
{
//lets create a new attachment
var newAttachment = Service.NewRecord(Entities.annotation);
newAttachment.SetLookup(Fields.annotation_.objectid, matchingRecord.Id, matchingRecord.Type);
newAttachment.SetField(Fields.annotation_.subject, fileInfo.Name, Service);
newAttachment.SetField(Fields.annotation_.filename, fileInfo.Name, Service);
newAttachment.SetField(Fields.annotation_.documentbody, contentBase64String, Service);
Service.Create(newAttachment);
thisResponseItem.Created = true;
}
}
else
{
//get the record with the same name as the file
var nameToMatch = fileInfo.Name.Substring(0, fileInfo.Name.LastIndexOf("."));
var matchingRecord = GetRecordToDeployInto(recordType, nameToMatch, containingFolderParentName);
if (matchingRecord == null)
{
throw new NullReferenceException($"There is no {Service.GetDisplayName(recordType)} record name {fileInfo.Name} to load the file attachment into");
}
thisResponseItem.Link = new Url(Service.GetWebUrl(matchingRecord.Type, matchingRecord.Id), "Open");
var targetField = GetTargetField(fileInfo, recordType);
var contentText = File.ReadAllText(file);
if (matchingRecord.GetStringField(targetField) != contentText)
{
matchingRecord.SetField(targetField, contentText, Service);
Service.Update(matchingRecord, new[] { targetField });
thisResponseItem.Updated = true;
}
}
}
catch (Exception ex)
{
thisResponseItem.Exception = ex;
}
}
}
public override void ExecuteExtention(DeployAssemblyRequest request, DeployAssemblyResponse response,
ServiceRequestController controller)
{
var service = Service;
controller.UpdateProgress(0, 4, "Processing Deletions");
var removedPlugins = request.GetPreTypeRecords().Where(ptr => request.PluginTypes.All(pt => pt.Id != ptr.Id)).ToArray();
var deletions = service.DeleteInCrm(removedPlugins);
response.AddResponseItems(deletions.Errors.Select(e => new DeployAssemblyResponseItem("Plugin Type Delete", e.Key.GetStringField(Fields.plugintype_.typename), e.Value)));
response.AddResponseItems(deletions.Deleted.Select(d => new DeployAssemblyResponseItem("Plugin Type Delete", d.GetStringField(Fields.plugintype_.typename))));
controller.UpdateProgress(1, 4, "Deploying Assembly");
//okay first create/update the plugin assembly
var assemblyRecord = service.NewRecord(Entities.pluginassembly);
assemblyRecord.Id = request.Id;
if (request.Id != null)
{
assemblyRecord.SetField(Fields.pluginassembly_.pluginassemblyid, request.Id, service);
}
assemblyRecord.SetField(Fields.pluginassembly_.name, request.AssemblyName, service);
assemblyRecord.SetField(Fields.pluginassembly_.content, request.Content, service);
assemblyRecord.SetField(Fields.pluginassembly_.isolationmode, (int)request.IsolationMode, service);
var matchField = Fields.pluginassembly_.pluginassemblyid;
var assemblyLoadResponse = service.LoadIntoCrm(new[] { assemblyRecord }, matchField);
foreach (var e in assemblyLoadResponse.Errors)
{
response.AddResponseItem(new DeployAssemblyResponseItem(e.Key.Id != null ? "Assembly Update" : "Assembly Create", e.Key.GetStringField(Fields.pluginassembly_.name), e.Value));
}
response.AddResponseItems(assemblyLoadResponse.Created.Select(d => new DeployAssemblyResponseItem("Assembly Create", d.GetStringField(Fields.pluginassembly_.name))));
response.AddResponseItems(assemblyLoadResponse.Updated.Select(d => new DeployAssemblyResponseItem("Assembly Update", d.GetStringField(Fields.pluginassembly_.name))));
if (assemblyLoadResponse.Errors.Any())
{
response.Message = $"The Process Did Not Complete Due To An Error Deploying The {Service.GetDisplayName(Entities.pluginassembly)} Record";
}
else
{
controller.UpdateProgress(2, 4, "Updating Plugin Types");
//okay create/update the plugin types
var pluginTypes = new List <IRecord>();
foreach (var pluginType in request.PluginTypes)
{
var pluginTypeRecord = service.NewRecord(Entities.plugintype);
pluginTypeRecord.Id = pluginType.Id;
if (pluginType.Id != null)
{
pluginTypeRecord.SetField(Fields.plugintype_.plugintypeid, pluginType.Id, service);
}
pluginTypeRecord.SetField(Fields.plugintype_.typename, pluginType.TypeName, service);
pluginTypeRecord.SetField(Fields.plugintype_.name, pluginType.Name, service);
pluginTypeRecord.SetField(Fields.plugintype_.friendlyname, pluginType.FriendlyName, service);
pluginTypeRecord.SetField(Fields.plugintype_.assemblyname, request.AssemblyName, service);
pluginTypeRecord.SetLookup(Fields.plugintype_.pluginassemblyid, assemblyRecord.Id, assemblyRecord.Type);
pluginTypeRecord.SetField(Fields.plugintype_.isworkflowactivity, pluginType.IsWorkflowActivity, service);
pluginTypeRecord.SetField(Fields.plugintype_.workflowactivitygroupname, pluginType.GroupName, service);
pluginTypes.Add(pluginTypeRecord);
}
var pluginTypeLoadResponse = service.LoadIntoCrm(pluginTypes, Fields.plugintype_.plugintypeid, setWorkflowRefreshField: request.TriggerWorkflowActivityRefreshes);
foreach (var e in pluginTypeLoadResponse.Errors)
{
response.AddResponseItem(new DeployAssemblyResponseItem(e.Key.Id != null ? "Plugin Type Update" : "Plugin Type Create", e.Key.GetStringField(Fields.plugintype_.typename), e.Value));
}
response.AddResponseItems(pluginTypeLoadResponse.Created.Select(d => new DeployAssemblyResponseItem("Plugin Type Create", d.GetStringField(Fields.plugintype_.typename))));
response.AddResponseItems(pluginTypeLoadResponse.Updated.Select(d => new DeployAssemblyResponseItem("Plugin Type Update", d.GetStringField(Fields.plugintype_.typename))));
//add plugin assembly to the solution
var componentType = OptionSets.SolutionComponent.ObjectTypeCode.PluginAssembly;
var itemsToAdd = assemblyLoadResponse.Created.Union(assemblyLoadResponse.Updated);
if (PackageSettings.AddToSolution)
{
controller.UpdateProgress(3, 4, "Adding Components To Solution");
service.AddSolutionComponents(PackageSettings.Solution.Id, componentType, itemsToAdd.Select(i => i.Id));
}
controller.UpdateProgress(4, 4, "Completing");
if (response.HasResponseItemError)
{
response.Message = "There Were Errors Thrown Updating The Plugins";
}
else if (response.HasResponseItems)
{
response.Message = "Plugins Updated";
}
else
{
response.Message = "No Updates Were Identified";
}
}
}
