private void RemoveUserFromTeams(Guid idUser, IEnumerable <Guid> teamList)
{
if (teamList == null || !teamList.Any())
{
return;
}
var hashSet = new HashSet <Guid>(teamList);
var userTeams = GetUserTeams(idUser, teamList.ToArray());
var teamsToRemove = userTeams.Where(r => hashSet.Contains(r)).ToArray();
if (!teamsToRemove.Any())
{
return;
}
var userArray = new[] { idUser };
foreach (var idTeam in teamsToRemove)
{
var request = new RemoveMembersTeamRequest()
{
TeamId = idTeam,
MemberIds = userArray,
};
var response = (RemoveMembersTeamResponse)_service.Execute(request);
}
}
private Translation GetTranslations()
{
Translation result = null;
try
{
var request = new ExportTranslationRequest()
{
SolutionName = "Default",
};
var response = (ExportTranslationResponse)_service.Execute(request);
var traslationZipFile = response.ExportTranslationFile;
var traslationFileBytes = FileOperations.UnzipCrmTranslations(traslationZipFile, "/CrmTranslations.xml");
string xml = Encoding.UTF8.GetString(traslationFileBytes);
xml = ContentCoparerHelper.RemoveDiacritics(xml);
XElement doc = XElement.Parse(xml);
result = new Translation();
FillTranslation(result, doc);
}
catch (Exception ex)
{
Helpers.DTEHelper.WriteExceptionToOutput(_service.ConnectionData, ex);
}
return(result);
}
private List <OptionSetMetadata> GetOptionSets()
{
RetrieveAllOptionSetsRequest request = new RetrieveAllOptionSetsRequest();
RetrieveAllOptionSetsResponse retrieve = (RetrieveAllOptionSetsResponse)_service.Execute(request);
return(retrieve
.OptionSetMetadata
.OfType <OptionSetMetadata>()
.Where(e => e.Options.Any(o => o.Value.HasValue))
.OrderBy(e => e.Name)
.ToList());
}
private Guid CreateNewWebResource(string name, string displayName, string description, string extension, string solutionUniqueName)
{
WebResource webResource = new WebResource()
{
LogicalName = WebResource.EntityLogicalName,
Attributes =
{
{ WebResource.Schema.Attributes.displayname, displayName },
{ WebResource.Schema.Attributes.name, name },
{ WebResource.Schema.Attributes.webresourcetype, new OptionSetValue(WebResourceRepository.GetTypeByExtension(extension)) }
}
};
if (!string.IsNullOrEmpty(description))
{
webResource.Attributes.Add(WebResource.Schema.Attributes.description, description);
}
CreateRequest request = new CreateRequest()
{
Target = webResource
};
request.Parameters.Add("SolutionUniqueName", solutionUniqueName);
CreateResponse response = (CreateResponse)_service.Execute(request);
return(response.id);
}
private byte[] ExportApplicationRibbonByteArray()
{
RetrieveApplicationRibbonRequest appribReq = new RetrieveApplicationRibbonRequest();
RetrieveApplicationRibbonResponse appribResp = (RetrieveApplicationRibbonResponse)_service.Execute(appribReq);
string fileName = "ApplicationRibbon.zip";
string directory = FileOperations.GetConnectionIntellisenseDataFolderPath(this._service.ConnectionData.ConnectionId);
string filePath = Path.Combine(directory, fileName);
var arrayXml = FileOperations.UnzipRibbon(appribResp.CompressedApplicationRibbonXml);
try
{
File.WriteAllBytes(filePath, appribResp.CompressedApplicationRibbonXml);
using (var memStream = new MemoryStream())
{
memStream.Write(arrayXml, 0, arrayXml.Length);
memStream.Position = 0;
XDocument doc = XDocument.Load(memStream);
_service.ConnectionData.RibbonIntellisense.ApplicationRibbonData.LoadDataFromRibbon(doc);
}
}
catch (Exception ex)
{
DTEHelper.WriteExceptionToOutput(this._service.ConnectionData, ex);
}
return(arrayXml);
}
private byte[] ExportApplicationRibbonByteArray()
{
RetrieveApplicationRibbonRequest appribReq = new RetrieveApplicationRibbonRequest();
RetrieveApplicationRibbonResponse appribResp = (RetrieveApplicationRibbonResponse)_service.Execute(appribReq);
return(appribResp.CompressedApplicationRibbonXml);
}
private static bool RemoveWrongEntityMetadataAttributes(IOrganizationServiceExtented service, List <string> list)
{
bool executeAgain = true;
while (executeAgain)
{
executeAgain = false;
try
{
MetadataFilterExpression entityFilter = new MetadataFilterExpression(LogicalOperator.And);
entityFilter.Conditions.Add(new MetadataConditionExpression(nameof(EntityMetadata.LogicalName), MetadataConditionOperator.Equals, SystemUser.EntityLogicalName));
var entityQueryExpression = new EntityQueryExpression()
{
Properties = new MetadataPropertiesExpression(nameof(EntityMetadata.LogicalName)),
Criteria = entityFilter,
};
entityQueryExpression.Properties.PropertyNames.AddRange(list);
var response = (RetrieveMetadataChangesResponse)service.Execute(
new RetrieveMetadataChangesRequest()
{
ClientVersionStamp = null,
Query = entityQueryExpression,
}
);
return(true);
}
catch (FaultException <OrganizationServiceFault> fex)
{
if (fex.Detail != null &&
fex.Detail.ErrorCode == -2147204733 &&
fex.Detail.InnerFault != null &&
fex.Detail.InnerFault.InnerFault != null &&
fex.Detail.InnerFault.InnerFault.Message.StartsWith("The type EntityMetadata does not have a property named ", StringComparison.InvariantCultureIgnoreCase)
)
{
var propertyName = fex.Detail.InnerFault.InnerFault.Message.Replace("The type EntityMetadata does not have a property named ", string.Empty);
list.Remove(propertyName);
executeAgain = true;
}
else
{
DTEHelper.WriteExceptionToLog(fex);
}
}
catch (Exception ex)
{
DTEHelper.WriteExceptionToLog(ex);
}
}
return(false);
}
private PluginAssembly GetAssemblyByIdByRetrieveRequest(Guid id, ColumnSet columnSet)
{
var request = new RetrieveRequest()
{
Target = new EntityReference(PluginAssembly.EntityLogicalName, id),
ColumnSet = columnSet ?? new ColumnSet(GetAttributes(_service)),
ReturnNotifications = true,
};
var response = (RetrieveResponse)_service.Execute(request);
return(response.Entity.ToEntity <PluginAssembly>());
}
private IEnumerable <RolePrivilege> GetUserPrivileges(Guid idUser)
{
var request = new RetrieveUserPrivilegesRequest()
{
UserId = idUser,
};
var response = (RetrieveUserPrivilegesResponse)_service.Execute(request);
return(response.RolePrivileges);
}
private string Export(ExportSolutionConfig config, ExportSolutionOverrideInformation solutionInfo)
{
var solution = _service.Retrieve(Solution.EntityLogicalName, config.IdSolution, ColumnSetInstances.AllColumns).ToEntity <Solution>();
string solutionName = solution.UniqueName;
string solutionVersion = solution.Version;
solutionVersion = RemoveSymbols(solutionVersion);
ExportSolutionRequest request = new ExportSolutionRequest()
{
SolutionName = solutionName,
Managed = config.Managed,
};
if (config.ExportAutoNumberingSettings)
{
request.ExportAutoNumberingSettings = config.ExportAutoNumberingSettings;
}
if (config.ExportCalendarSettings)
{
request.ExportCalendarSettings = config.ExportCalendarSettings;
}
if (config.ExportCustomizationSettings)
{
request.ExportCustomizationSettings = config.ExportCustomizationSettings;
}
if (config.ExportEmailTrackingSettings)
{
request.ExportEmailTrackingSettings = config.ExportEmailTrackingSettings;
}
if (config.ExportExternalApplications)
{
request.ExportExternalApplications = config.ExportExternalApplications;
}
if (config.ExportGeneralSettings)
{
request.ExportGeneralSettings = config.ExportGeneralSettings;
}
if (config.ExportIsvConfig)
{
request.ExportIsvConfig = config.ExportIsvConfig;
}
if (config.ExportMarketingSettings)
{
request.ExportMarketingSettings = config.ExportMarketingSettings;
}
if (config.ExportOutlookSynchronizationSettings)
{
request.ExportOutlookSynchronizationSettings = config.ExportOutlookSynchronizationSettings;
}
if (config.ExportRelationshipRoles)
{
request.ExportRelationshipRoles = config.ExportRelationshipRoles;
}
if (config.ExportSales)
{
request.ExportSales = config.ExportSales;
}
var response = (ExportSolutionResponse)_service.Execute(request);
var fileBody = response.ExportSolutionFile;
if (!Directory.Exists(config.ExportFolder))
{
Directory.CreateDirectory(config.ExportFolder);
}
if (solutionInfo.OverrideNameAndVersion || solutionInfo.OverrideDescription)
{
fileBody = OverrideSolutionInformation(fileBody, solutionInfo);
}
string fileName = string.Format("{0}.{1}_{2}{3} at {4}.zip"
, config.ConnectionName
, solutionName
, solutionVersion
, (config.Managed ? "_managed" : string.Empty)
, EntityFileNameFormatter.GetDateString()
);
string filePath = Path.Combine(config.ExportFolder, FileOperations.RemoveWrongSymbols(fileName));
File.WriteAllBytes(filePath, fileBody);
return(filePath);
}
private async Task UpdateSavedQueryXml(IOrganizationServiceExtented service, CommonConfiguration commonConfig, XDocument doc, string filePath, SavedQuery savedQuery)
{
string fieldName = SavedQueryRepository.GetFieldNameByXmlRoot(doc.Root.Name.ToString());
string fieldTitle = SavedQueryRepository.GetFieldTitleByXmlRoot(doc.Root.Name.ToString());
if (string.Equals(fieldName, SavedQuery.Schema.Attributes.layoutxml, StringComparison.InvariantCulture) &&
!string.IsNullOrEmpty(savedQuery.ReturnedTypeCode)
)
{
var entityData = service.ConnectionData.GetEntityIntellisenseData(savedQuery.ReturnedTypeCode);
if (entityData != null && entityData.ObjectTypeCode.HasValue)
{
XAttribute attr = doc.Root.Attribute("object");
if (attr != null)
{
attr.Value = entityData.ObjectTypeCode.ToString();
}
}
}
{
string xmlContent = savedQuery.GetAttributeValue <string>(fieldName);
if (!string.IsNullOrEmpty(xmlContent))
{
commonConfig.CheckFolderForExportExists(this._iWriteToOutput);
string fileNameBackUp = EntityFileNameFormatter.GetSavedQueryFileName(service.ConnectionData.Name, savedQuery.ReturnedTypeCode, savedQuery.Name, fieldTitle + " BackUp", FileExtension.xml);
string filePathBackUp = Path.Combine(commonConfig.FolderForExport, FileOperations.RemoveWrongSymbols(fileNameBackUp));
try
{
xmlContent = ContentComparerHelper.FormatXmlByConfiguration(
xmlContent
, commonConfig
, XmlOptionsControls.SavedQueryXmlOptions
, schemaName: AbstractDynamicCommandXsdSchemas.FetchSchema
, savedQueryId: savedQuery.Id
, entityName: savedQuery.ReturnedTypeCode
);
File.WriteAllText(filePathBackUp, xmlContent, new UTF8Encoding(false));
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldExportedToFormat5, service.ConnectionData.Name, SavedQuery.Schema.EntityLogicalName, savedQuery.Name, fieldTitle, filePathBackUp);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
}
else
{
this._iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionEntityFieldIsEmptyFormat4, service.ConnectionData.Name, SavedQuery.Schema.EntityLogicalName, savedQuery.Name, fieldTitle);
this._iWriteToOutput.ActivateOutputWindow(service.ConnectionData);
}
}
var newText = doc.ToString(SaveOptions.DisableFormatting);
if (string.Equals(fieldName, SavedQuery.Schema.Attributes.fetchxml, StringComparison.InvariantCulture))
{
try
{
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.ExecutingValidateSavedQueryRequest);
var request = new ValidateSavedQueryRequest()
{
FetchXml = newText,
QueryType = savedQuery.QueryType.GetValueOrDefault()
};
service.Execute(request);
}
catch (Exception ex)
{
this._iWriteToOutput.WriteErrorToOutput(service.ConnectionData, ex);
}
}
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.SavingEntityFormat1, savedQuery.LogicalName);
_iWriteToOutput.WriteToOutputEntityInstance(service.ConnectionData, savedQuery.LogicalName, savedQuery.Id);
var updateEntity = new SavedQuery
{
Id = savedQuery.Id,
};
updateEntity.Attributes[fieldName] = newText;
await service.UpdateAsync(updateEntity);
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.SavingEntityCompletedFormat1, savedQuery.LogicalName);
_iWriteToOutput.WriteToOutput(service.ConnectionData, Properties.OutputStrings.InConnectionPublishingEntitiesFormat2, service.ConnectionData.Name, savedQuery.ReturnedTypeCode);
{
var repositoryPublish = new PublishActionsRepository(service);
await repositoryPublish.PublishEntitiesAsync(new[] { savedQuery.ReturnedTypeCode });
}
service.TryDispose();
}
private List <EntityMetadata> GetEntitiesDisplayName()
{
MetadataPropertiesExpression entityProperties = new MetadataPropertiesExpression
(
nameof(EntityMetadata.LogicalName)
, nameof(EntityMetadata.DisplayName)
, nameof(EntityMetadata.SchemaName)
, nameof(EntityMetadata.Description)
, nameof(EntityMetadata.DisplayCollectionName)
, nameof(EntityMetadata.OwnershipType)
, nameof(EntityMetadata.IsIntersect)
, nameof(EntityMetadata.ObjectTypeCode)
)
{
AllProperties = false
};
EntityQueryExpression entityQueryExpression = new EntityQueryExpression()
{
Properties = entityProperties,
};
RetrieveMetadataChangesRequest request = new RetrieveMetadataChangesRequest()
{
Query = entityQueryExpression,
};
RetrieveMetadataChangesResponse response = (RetrieveMetadataChangesResponse)_service.Execute(request);
return(response.EntityMetadata.OrderBy(ent => ent.LogicalName).ToList());
}
private static string[] GetAttributes(IOrganizationServiceExtented service)
{
if (_fields != null)
{
return(_fields);
}
MetadataFilterExpression entityFilter = new MetadataFilterExpression(LogicalOperator.And);
entityFilter.Conditions.Add(new MetadataConditionExpression(nameof(Entity.LogicalName), MetadataConditionOperator.Equals, WebResource.EntityLogicalName));
var entityQueryExpression = new EntityQueryExpression()
{
Properties = new MetadataPropertiesExpression(nameof(Entity.Attributes)),
AttributeQuery = new AttributeQueryExpression()
{
Properties = new MetadataPropertiesExpression()
{
AllProperties = true
}
},
Criteria = entityFilter,
};
var response = (RetrieveMetadataChangesResponse)service.Execute(
new RetrieveMetadataChangesRequest()
{
ClientVersionStamp = null,
Query = entityQueryExpression,
}
);
var metadata = response.EntityMetadata.SingleOrDefault(e => string.Equals(e.LogicalName, WebResource.EntityLogicalName, StringComparison.InvariantCultureIgnoreCase));
if (metadata == null)
{
_fields = new string[0];
return(_fields);
}
var list = new List <string>();
foreach (var attr in metadata.Attributes.OrderBy(a => a.LogicalName))
{
if (!string.IsNullOrEmpty(attr.AttributeOf))
{
continue;
}
if (string.Equals(attr.LogicalName, WebResource.Schema.Attributes.content, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
if (!attr.IsValidForRead.GetValueOrDefault()
//&& !attr.IsValidForCreate.GetValueOrDefault()
//&& !attr.IsValidForUpdate.GetValueOrDefault()
//&& !attr.IsValidForAdvancedFind.Value
)
{
continue;
}
list.Add(attr.LogicalName);
}
_fields = list.ToArray();
return(_fields);
}
private async Task RegisterSingleStep(StringBuilder log, SdkMessageRepository repositoryMessage, SdkMessageFilterRepository repositoryFilter, SystemUserRepository repositorySystemUser, Entities.PluginType entPluginType, Model.Backup.PluginStep step)
{
var entMessage = await repositoryMessage.FindMessageAsync(step.Message);
if (entMessage == null)
{
log.AppendFormat("Message {0} not founded in CRM.", step.Message).AppendLine();
return;
}
var refMessageFilter = await repositoryFilter.FindFilterAsync(entMessage.Id, step.PrimaryEntity, step.SecondaryEntity);
EntityReference refSecure = null;
EntityReference refSystemUser = null;
if (!string.IsNullOrEmpty(step.SecureConfiguration))
{
var entSecure = new Entity(Entities.SdkMessageProcessingStepSecureConfig.EntityLogicalName);
entSecure.Attributes[Entities.SdkMessageProcessingStepSecureConfig.Schema.Attributes.secureconfig] = step.SecureConfiguration;
entSecure.Id = await _service.CreateAsync(entSecure);
refSecure = entSecure.ToEntityReference();
}
if (!string.IsNullOrEmpty(step.RunInUserContext) && step.RunInUserContext != "Calling User")
{
refSystemUser = repositorySystemUser.FindUser(step.RunInUserContext);
}
var entStep = new Entity(Entities.SdkMessageProcessingStep.EntityLogicalName)
{
Id = step.Id
};
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.asyncautodelete] = step.AsyncAutoDelete.GetValueOrDefault();
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.name] = step.Name;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.description] = step.Description;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.rank] = step.ExecutionOrder;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.stage] = new OptionSetValue((int)step.Stage);
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.mode] = new OptionSetValue((int)step.ExecutionMode);
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.supporteddeployment] = new OptionSetValue((int)step.SupportedDeploymentCode);
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.configuration] = step.UnsecureConfiguration;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.filteringattributes] = string.Join(",", step.FilteringAttributes.OrderBy(s => s));
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.plugintypeid] = entPluginType.ToEntityReference();
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.eventhandler] = entPluginType.ToEntityReference();
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.sdkmessageid] = entMessage.ToEntityReference();
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.sdkmessagefilterid] = refMessageFilter;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.sdkmessageprocessingstepsecureconfigid] = refSecure;
entStep.Attributes[Entities.SdkMessageProcessingStep.Schema.Attributes.impersonatinguserid] = refSystemUser;
entStep.Id = await _service.CreateAsync(entStep);
foreach (var image in step.PluginImages)
{
var entImage = new Entity(Entities.SdkMessageProcessingStepImage.EntityLogicalName)
{
Id = image.Id
};
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.sdkmessageprocessingstepid] = entStep.ToEntityReference();
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.imagetype] = new OptionSetValue(image.ImageType.Value);
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.name] = image.Name;
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.entityalias] = image.EntityAlias;
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.customizationlevel] = image.CustomizationLevel;
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.relatedattributename] = image.RelatedAttributeName;
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.messagepropertyname] = image.MessagePropertyName;
entImage.Attributes[Entities.SdkMessageProcessingStepImage.Schema.Attributes.attributes] = string.Join(",", image.Attributes.OrderBy(s => s));
entImage.Id = await _service.CreateAsync(entImage);
}
_service.Execute(new SetStateRequest()
{
EntityMoniker = entStep.ToEntityReference(),
State = new OptionSetValue(step.StateCode.Value),
Status = new OptionSetValue(step.StatusCode.Value),
});
}
private void PublishAllXml()
{
var request = new PublishAllXmlRequest();
var response = (PublishAllXmlResponse)_service.Execute(request);
}
