public CyclicLinkConflictDetails(ConflictDetailsProperties detailsProperties)
{
string sourceItemId, targetItemId, linkType, closure;
if (detailsProperties.Properties.TryGetValue(
TFSCyclicLinkConflictType.ConflictDetailsKey_SourceWorkItemID, out sourceItemId) &&
detailsProperties.Properties.TryGetValue(
TFSCyclicLinkConflictType.ConflictDetailsKey_TargetWorkItemID, out targetItemId) &&
detailsProperties.Properties.TryGetValue(
TFSCyclicLinkConflictType.ConflictDetailsKey_LinkType, out linkType) &&
detailsProperties.Properties.TryGetValue(
TFSCyclicLinkConflictType.ConflictDetailsKey_LinkClosure, out closure))
{
this.SourceWorkItemID = sourceItemId;
this.TargetWorkItemID = targetItemId;
this.LinkTypeReferenceName = linkType;
GenericSerializer <List <LinkDescription> > serializer = new GenericSerializer <List <LinkDescription> >();
if (string.IsNullOrEmpty(closure))
{
this.LinkReferenceClosure = new List <LinkDescription>();
}
else
{
this.LinkReferenceClosure = serializer.Deserialize(closure);
}
}
else
{
throw new ArgumentException("detailsProperties do not contain all expected values for the conflict type");
}
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
CyclicLinkConflictDetails details = new CyclicLinkConflictDetails(properties);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format(TfsWITAdapterResources.CyclicalLinkError, details.SourceWorkItemID, details.TargetWorkItemID, details.LinkTypeReferenceName));
if (details.LinkReferenceClosure.Count > 0)
{
stringBuilder.AppendLine();
stringBuilder.AppendLine(TfsWITAdapterResources.LinkClosureHeader);
stringBuilder.AppendLine("SOURCE\tTARGET");
foreach (LinkDescription link in details.LinkReferenceClosure)
{
stringBuilder.AppendLine(string.Format("{0}\t{1}", link.SourceWorkItemId, link.TargetWorkItemId));
}
}
return(stringBuilder.ToString());
}
catch (Exception)
{
return(dtls);
}
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
if (!string.IsNullOrEmpty(properties[ConflictDetailsKey_UserName]) &&
!string.IsNullOrEmpty(properties[ConflictDetailsKey_MissingPrivilegeName]))
{
return(CreateOldStyleConflictDetails(
properties[ConflictDetailsKey_UserName], properties[ConflictDetailsKey_MissingPrivilegeName]));
}
else
{
// no expected data, just return raw details string
return(dtls);
}
}
catch (Exception)
{
// old style conflict details, just return raw details string
return(dtls);
}
}
internal InvalidFieldConflictTypeDetails(ConflictDetailsProperties detailsProperties)
{
string srcWitId, srcWitRev, srcFldRefName, tgtTP, tgtWit, tgtSvrUrl;
if (detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_SourceWorkItemId, out srcWitId) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_SourceWorkItemRevision, out srcWitRev) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_SourceFieldRefName, out srcFldRefName) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_TargetTeamProject, out tgtTP) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_TargetWorkItemType, out tgtWit) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldConflictTypeConstants.ConflictDetailsKey_TargetTeamFoundationServerUrl,
out tgtSvrUrl))
{
SourceWorkItemID = srcWitId;
SourceWorkItemRevision = srcWitRev;
SourceFieldRefName = srcFldRefName;
TargetTeamProject = tgtTP;
TargetWorkItemType = tgtWit;
TargetTeamFoundationServerUrl = tgtSvrUrl;
}
else
{
throw new ArgumentException();
}
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
if (!string.IsNullOrEmpty(properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_AttachmentName]))
{
return(string.Format(TfsWITAdapterResources.ErrorAttachmentFileExceedsMaxSize,
properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_WorkItemId],
properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_AttachmentName],
properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_FileSize],
properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_MaxAttachmentSize]));
}
else
{
// no expected data, just return raw details string
return(dtls);
}
}
catch (Exception)
{
// old style conflict details, just return raw details string
return(dtls);
}
}
private static string CreateConflictDetails(string userName, string missingPrivilegeName)
{
ConflictDetailsProperties detailsProperties = new ConflictDetailsProperties();
detailsProperties.Properties.Add(ConflictDetailsKey_UserName, userName);
detailsProperties.Properties.Add(ConflictDetailsKey_MissingPrivilegeName, missingPrivilegeName);
return(detailsProperties.ToString());
}
private void SetMinFileSize()
{
ConflictDetailsProperties properties = m_viewModel.MigrationConflict.ConflictDetailsProperties;
string fileSize = properties[FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_FileSize];
ObservableDataField fileSizeDataField = m_viewModel.ObservableDataFields.FirstOrDefault(x => string.Equals(x.FieldName, FileAttachmentOversizedConflictDropAttachmentAction.DATAKEY_MIN_FILE_SIZE_TO_DROP));
Debug.Assert(fileSizeDataField != null, string.Format("No DataField with key {0}", FileAttachmentOversizedConflictDropAttachmentAction.DATAKEY_MIN_FILE_SIZE_TO_DROP));
fileSizeDataField.FieldValue = fileSize;
}
private static string CreateConflictDetails(CQTextParser.RecordValidationResult rslt, IMigrationAction action)
{
ConflictDetailsProperties detailsProperties = new ConflictDetailsProperties();
string recordType = UtilityMethods.ExtractRecordType(action);
detailsProperties.Properties.Add(ConflictDetailsKey_RecordType, recordType);
detailsProperties.Properties.Add(ConflictDetailsKey_FieldName, rslt.InvalidFieldName ?? string.Empty);
detailsProperties.Properties.Add(ConflictDetailsKey_FieldValue, rslt.InvalidFieldValue ?? string.Empty);
detailsProperties.Properties.Add(ConflictDetailsKey_Reason, rslt.ResultDescription.ToString());
return(detailsProperties.ToString());
}
public UpdateConfigConflictViewModelBase(ConflictRuleViewModel viewModel)
{
m_conflictRuleViewModel = viewModel;
m_configuration = m_conflictRuleViewModel.AppViewModel.Config;
m_session = m_configuration.SessionGroup.Sessions.Session.First(x => m_conflictRuleViewModel.RTConflict.ScopeId.Equals(new Guid(x.SessionUniqueId)));
m_customSettings = new SerializableCustomSettings(m_session);
m_cachedCustomSettings = m_customSettings.Serialize();
m_properties = m_conflictRuleViewModel.MigrationConflict.ConflictDetailsProperties;
string str;
HasProperties = !m_properties.TryGetValue(ConflictDetailsProperties.DefaultConflictDetailsKey, out str);
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
if (!string.IsNullOrEmpty(properties[ConflictDetailsKey_RecordType]))
{
string conflictDescription;
switch (properties[ConflictDetailsKey_Reason])
{
case "MissingValueInMandatoryField":
conflictDescription = "Source work item '{0}' is missing value in mandatory field '{1}'.";
break;
case "InvalidValueOfChoiceList":
conflictDescription = "Source work item '{0}' contains the invalid value of '{2}' in field '{1}'.";
break;
default:
conflictDescription = "Source work item '{0}' contains invalid field change on '{1}' in value '{2}' because '{3}'.";
break;
}
return(string.Format(conflictDescription,
properties[ConflictDetailsKey_RecordType],
properties[ConflictDetailsKey_FieldName],
properties[ConflictDetailsKey_FieldValue],
properties[ConflictDetailsKey_Reason]));
}
else
{
// no expected data, just return raw details string
return(dtls);
}
}
catch (Exception)
{
// old style conflict details, just return raw details string
return(dtls);
}
}
internal WorkItemTypeNotExistConflictTypeDetails(ConflictDetailsProperties detailsProperties)
{
string tfsName, teamProjectName, workItemType;
if (detailsProperties.Properties.TryGetValue(
WorkItemTypeNotExistConflictTypeConstants.ConflictDetailsKey_TeamFoundationServer, out tfsName) &&
detailsProperties.Properties.TryGetValue(
WorkItemTypeNotExistConflictTypeConstants.ConflictDetailsKey_TeamProject, out teamProjectName) &&
detailsProperties.Properties.TryGetValue(
WorkItemTypeNotExistConflictTypeConstants.ConflictDetailsKey_MissingWorkItemType, out workItemType))
{
Initialize(tfsName, teamProjectName, workItemType);
}
else
{
throw new ArgumentException("detailsProperties do not contain all expected values for the conflict type");
}
}
/// <summary>
/// Creates a conflict of this type
/// </summary>
/// <param name="migrationSourceId">The Unique Id of the migration source, for which the conflict is reported</param>
/// <param name="ex">The permission exception that contains the details of the conflict</param>
/// <returns>The created conflict instance</returns>
public static MigrationConflict CreateConflict(
Guid migrationSourceId,
PermissionException ex)
{
ConflictDetailsProperties detailsProperty = new ConflictDetailsProperties();
detailsProperty.Properties[InsufficientPermissionConflictTypeConstants.ConflictDetailsKey_UserAlias]
= ex.UserAlias;
detailsProperty.Properties[InsufficientPermissionConflictTypeConstants.ConflictDetailsKey_UserDomain]
= ex.UserDomain;
detailsProperty.Properties[InsufficientPermissionConflictTypeConstants.ConflictDetailsKey_PermissionGroupName]
= ex.RequiredGroupAccountDisplayName;
detailsProperty.Properties[Constants.ConflictDetailsKey_MigrationSourceId]
= migrationSourceId.ToString();
return(new MigrationConflict(new InsufficientPermissionConflictType(),
MigrationConflict.Status.Unresolved,
detailsProperty.ToString(),
BasicPathScopeInterpreter.PathSeparator + migrationSourceId.ToString()));
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
WorkItemTypeNotExistConflictTypeDetails details = null;
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
details = new WorkItemTypeNotExistConflictTypeDetails(properties);
}
catch (Exception)
{
try
{
GenericSerializer <WorkItemTypeNotExistConflictTypeDetails> serializer =
new GenericSerializer <WorkItemTypeNotExistConflictTypeDetails>();
details = serializer.Deserialize(dtls);
}
catch (Exception)
{
// do nothing, fall back to raw string later
}
}
if (null != details)
{
return(string.Format(
"Work Item Type {0} is not defined for team project '{1}' on server '{2}'.",
details.MissingWorkItemType,
details.TeamProject,
details.TeamFoundationServer));
}
else
{
return(dtls);
}
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
InvalidFieldConflictTypeDetails details = null;
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
details = new InvalidFieldConflictTypeDetails(properties);
}
catch (Exception)
{
try
{
GenericSerializer <InvalidFieldConflictTypeDetails> serializer =
new GenericSerializer <InvalidFieldConflictTypeDetails>();
details = serializer.Deserialize(dtls);
}
catch (Exception)
{
// do nothing, fall back to raw string later
}
}
if (null != details)
{
return(string.Format(
"Source Item {0} (revision {1}) contains Field {2} that does not exist on Work Item Type '{3}' of the target project '{4}'.",
details.SourceWorkItemID, details.SourceWorkItemRevision,
details.SourceFieldRefName, details.TargetWorkItemType, details.TargetTeamProject));
}
else
{
return(dtls);
}
}
internal InvalidFieldValueConflictTypeDetails(ConflictDetailsProperties detailsProperties)
{
string sourceItemId, sourceItemRevision, targetFieldRefName, targetFieldDispName, targetFieldOriginalValue,
targetFieldCurrentValue, targetTeamProjectName, targetWorkItemType, targetTFSUrl;
if (detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_SourceWorkItemID, out sourceItemId) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_SourceWorkItemRevision, out sourceItemRevision) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetTeamProject, out targetTeamProjectName) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetWorkItemType, out targetWorkItemType) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetFieldRefName, out targetFieldRefName) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetFieldDispName, out targetFieldDispName) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetFieldOriginalValue, out targetFieldOriginalValue) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetFieldCurrentValue, out targetFieldCurrentValue) &&
detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_TargetTeamFoundationServerUrl, out targetTFSUrl))
{
// for backward compatibility, reason is read from the property bag separately
string reason;
if (!detailsProperties.Properties.TryGetValue(
InvalidFieldValueConflictTypeConstants.ConflictDetailsKey_Reason, out reason))
{
reason = string.Empty;
}
Initialize(sourceItemId, sourceItemRevision, targetFieldRefName, targetFieldDispName,
targetFieldOriginalValue, targetFieldCurrentValue, targetTeamProjectName,
targetWorkItemType, targetTFSUrl, reason);
}
else
{
throw new ArgumentException("detailsProperties do not contain all expected values for the conflict type");
}
}
public override string TranslateConflictDetailsToReadableDescription(string dtls)
{
if (string.IsNullOrEmpty(dtls))
{
throw new ArgumentNullException("dtls");
}
InvalidFieldValueConflictTypeDetails details = null;
try
{
ConflictDetailsProperties properties = ConflictDetailsProperties.Deserialize(dtls);
details = new InvalidFieldValueConflictTypeDetails(properties);
}
catch (Exception)
{
try
{
GenericSerializer <InvalidFieldValueConflictTypeDetails> serializer =
new GenericSerializer <InvalidFieldValueConflictTypeDetails>();
details = serializer.Deserialize(dtls);
}
catch (Exception)
{
// do nothing, fall back to raw string later
}
}
if (null != details)
{
return(string.Format(
"Source work item {0} (revision {1}) contains invalid field change on {2} from '{3}' to '{4}' in target project '{5}'.",
details.SourceWorkItemID, details.SourceWorkItemRevision,
details.TargetFieldRefName, details.TargetFieldOriginalValue,
details.TargetFieldCurrentValue, details.TargetTeamProject));
}
else
{
return(dtls);
}
}
/// <summary>
/// Creates the details of this conflict
/// </summary>
/// <param name="attachmentName"></param>
/// <param name="fileSize"></param>
/// <param name="maxAttachmentSize"></param>
/// <param name="workItemId"></param>
/// <param name="serverName"></param>
/// <param name="teamProject"></param>
/// <returns></returns>
public static string CreateConflictDetails(
string attachmentName,
string fileSize,
long maxAttachmentSize,
string workItemId,
string serverName,
string teamProject)
{
ConflictDetailsProperties detailsProperties = new ConflictDetailsProperties();
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_AttachmentName, attachmentName);
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_FileSize, fileSize);
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_MaxAttachmentSize, maxAttachmentSize.ToString());
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_WorkItemId, workItemId);
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_ServerName, serverName);
detailsProperties.Properties.Add(
FileAttachmentOversizedConflictTypeConstants.ConflictDetailsKey_TeamProject, teamProject);
return(detailsProperties.ToString());
}
