public void UpdateValueListAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new ValueListNameParser(nameTemplate, converter);
var valueLists = Vault.ValueListOperations.GetValueListsAdmin()?.Cast <ObjTypeAdmin>();
if (valueLists == null)
{
return;
}
foreach (var valueList in valueLists)
{
if (valueList.ObjectType.RealObjectType)
{
continue;
}
UpdateAlias(valueList,
(vl) => Vault.ValueListOperations.UpdateValueListAdmin(vl),
parser,
behaviour,
valueList.SemanticAliases,
dryRun);
}
}
private static void OnCharacterCasingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var val = (CharacterCasing)e.NewValue;
DependencyProperty prop = d switch
{
TextBlock txt => TextBlock.TextProperty,
TextBox tbox => TextBox.PlaceholderTextProperty,
ButtonBase hBtn => ButtonBase.ContentProperty,
PivotItem pvi => PivotItem.HeaderProperty,
_ => throw new ArgumentException(),
};
d.RegisterPropertyChangedCallback(prop, (s, e) =>
{
if (_mutex)
{
return;
}
_mutex = true;
d.SetValue(prop, CaseConverter.Convert((string)d.GetValue(prop), val));
_mutex = false;
});
}
static Func <DataStorage.WarewolfAtom, DataStorage.WarewolfAtom> TryConvertFunc(ICaseConvertTO conversionType, IExecutionEnvironment env, int update)
{
var convertFunct = CaseConverter.GetFuncs();
if (convertFunct.TryGetValue(conversionType.ConvertType, out Func <string, string> returnedFunc) && returnedFunc != null)
{
return(a =>
{
var upper = returnedFunc.Invoke(a.ToString());
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
if (evalled is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult warewolfAtomResult)
{
return warewolfAtomResult.Item;
}
return DataStorage.WarewolfAtom.Nothing;
}
return DataStorage.WarewolfAtom.NewDataString(CommonFunctions.evalResultToString(evalled));
});
}
throw new Exception(ErrorResource.ConvertOptionDoesNotExist);
}
private Func <DataASTMutable.WarewolfAtom, DataASTMutable.WarewolfAtom> TryConvertFunc(ICaseConvertTO conversionType, IExecutionEnvironment env, int update)
{
var convertFunct = CaseConverter.GetFuncs();
Func <string, string> returnedFunc;
if (convertFunct.TryGetValue(conversionType.ConvertType, out returnedFunc))
{
if (returnedFunc != null)
{
return(a =>
{
var upper = returnedFunc.Invoke(a.ToString());
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
var warewolfAtomResult = evalled as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (warewolfAtomResult != null)
{
return warewolfAtomResult.Item;
}
return DataASTMutable.WarewolfAtom.Nothing;
}
return DataASTMutable.WarewolfAtom.NewDataString(WarewolfDataEvaluationCommon.EvalResultToString(evalled));
});
}
}
throw new Exception("Convert option does not exist");
}
public void ctor_that_takes_source_casing_and_target_casing_should_set_source_casing_and_target_casing()
{
var converter = new CaseConverter(CharacterCasing.Upper, CharacterCasing.Lower);
Assert.Equal(CharacterCasing.Upper, converter.SourceCasing);
Assert.Equal(CharacterCasing.Lower, converter.TargetCasing);
}
public void casing_throws_if_invalid_value_is_assigned()
{
var converter = new CaseConverter();
var ex = Assert.Throws <ArgumentException>(() => converter.Casing = (CharacterCasing)100);
Assert.Equal("Enum value '100' is not defined for enumeration 'System.Windows.Controls.CharacterCasing'.\r\nParameter name: value", ex.Message);
}
public void UpdateStateAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new StateNameParser(nameTemplate, converter);
var workflows = Vault.WorkflowOperations.GetWorkflowsAdmin()?.Cast <WorkflowAdmin>();
if (workflows == null)
{
return;
}
foreach (var workflow in workflows)
{
var states = workflow.States?.Cast <StateAdmin>();
if (states is null)
{
continue;
}
foreach (var state in states)
{
UpdateAlias(state,
(s) => { },
parser,
behaviour,
state.SemanticAliases,
dryRun);
}
if (!dryRun)
{
Vault.WorkflowOperations.UpdateWorkflowAdmin(workflow);
}
}
}
public void UpdateObjTypeAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new ObjectTypeNameParser(nameTemplate, converter);
var objTypes = Vault.ObjectTypeOperations.GetObjectTypesAdmin()?.Cast <ObjTypeAdmin>();
if (objTypes == null)
{
return;
}
foreach (var objType in objTypes)
{
if (!objType.ObjectType.RealObjectType)
{
continue;
}
UpdateAlias(objType,
(ot) => Vault.ObjectTypeOperations.UpdateObjectTypeAdmin(ot),
parser,
behaviour,
objType.SemanticAliases,
dryRun);
}
}
public void convert_return_unset_value_if_value_is_not_a_string()
{
var converter = new CaseConverter();
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(123, null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(123d, null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(DateTime.Now, null, null, null));
}
public void WhenIsCamelCase_ThenReturnSameString()
{
var sut = "camelCase";
var result = CaseConverter.ToCamelCase(sut, CaseType.CamelCase);
Assert.That(result, Is.EqualTo(sut));
}
public void WhenIsKebabCase_ThenReturnSameString()
{
const string value = "kebab-case";
var result = CaseConverter.ToKebabCase(value, CaseType.KebabCase);
Assert.That(result, Is.EqualTo(value));
}
public void WhenIsSnakeUpperCase_ThenReturnSameString()
{
var sut = "SNAKE_UPPER_CASE";
var result = CaseConverter.ToSnakeUpperCase(sut, CaseType.SnakeUpperCase);
Assert.That(result, Is.EqualTo(sut));
}
public void WhenIsSnakeCase_ThenReturnSameString()
{
var sut = "snake_case";
var result = CaseConverter.ToSnakeCase(sut, CaseType.SnakeCase);
Assert.That(result, Is.EqualTo(sut));
}
public void WhenIsPascalCase_ThenReturnSameString()
{
const string value = "PascalCase";
var result = CaseConverter.ToPascalCase(value, CaseType.PascalCase);
Assert.That(result, Is.EqualTo(value));
}
public void ctor_that_takes_single_casing_should_set_source_casing_and_target_casing_to_that_casing()
{
var converter = new CaseConverter(CharacterCasing.Upper);
Assert.Equal(CharacterCasing.Upper, converter.SourceCasing);
Assert.Equal(CharacterCasing.Upper, converter.TargetCasing);
converter = new CaseConverter(CharacterCasing.Lower);
Assert.Equal(CharacterCasing.Lower, converter.SourceCasing);
Assert.Equal(CharacterCasing.Lower, converter.TargetCasing);
}
public void convert_returns_same_value_if_target_casing_is_normal()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Normal
};
Assert.Equal("abcd", converter.Convert("abcd", null, null, null));
Assert.Equal("ABCD", converter.Convert("ABCD", null, null, null));
Assert.Equal("AbCd", converter.Convert("AbCd", null, null, null));
}
public void convert_returns_upper_cased_value_if_target_casing_is_upper()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Upper
};
Assert.Equal("ABCD", converter.Convert("abcd", null, null, null));
Assert.Equal("ABCD", converter.Convert("ABCD", null, null, null));
Assert.Equal("ABCD", converter.Convert("AbCd", null, null, null));
}
public void convert_back_returns_upper_cased_value_if_source_casing_is_upper()
{
var converter = new CaseConverter
{
SourceCasing = CharacterCasing.Upper
};
Assert.Equal("ABCD", converter.ConvertBack("abcd", null, null, null));
Assert.Equal("ABCD", converter.ConvertBack("ABCD", null, null, null));
Assert.Equal("ABCD", converter.ConvertBack("AbCd", null, null, null));
}
public Table ConvertClassToTable(ObjectClass @class, CaseConverter converter, bool ignoreBuiltinProperties)
{
var propertyDefs = Vault.PropertyDefOperations.GetPropertyDefs().Cast <PropertyDef>();
var table = new Table(
GetTableName(converter, @class),
GetTableColumns(converter, @class, propertyDefs, ignoreBuiltinProperties)
);
Log.Debug("Converted M-Files class {class} to an sql table.", @class?.Name);
return(table);
}
public void convert_uses_specified_culture_when_converting_to_lower_case()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Lower
};
var cultureInfo = new CultureInfo("tr");
Assert.Equal("ijk", converter.Convert("ijk", null, null, cultureInfo));
Assert.Equal("ıjk", converter.Convert("IJK", null, null, cultureInfo));
Assert.Equal("ijk", converter.Convert("iJk", null, null, cultureInfo));
}
public void convert_back_uses_specified_culture_when_converting_to_upper_case()
{
var converter = new CaseConverter
{
SourceCasing = CharacterCasing.Upper
};
var cultureInfo = new CultureInfo("tr");
Assert.Equal("İJK", converter.ConvertBack("ijk", null, null, cultureInfo));
Assert.Equal("IJK", converter.ConvertBack("IJK", null, null, cultureInfo));
Assert.Equal("İJK", converter.ConvertBack("iJk", null, null, cultureInfo));
}
public Table ConvertClassToTable(string @class, CaseConverter converter, bool ignoreBuiltinProperties)
{
var classObj = Vault.ClassOperations.GetAllObjectClasses()?
.Cast <ObjectClass>()?
.FirstOrDefault(c => c?.Name?.ToLower() == @class?.ToLower());
if (classObj is null)
{
throw new Exception($"Unable to fetch class {@class} from vault.");
}
return(ConvertClassToTable(classObj, converter, ignoreBuiltinProperties));
}
public void casing_sets_both_source_casing_and_target_casing()
{
var converter = new CaseConverter();
Assert.Equal(CharacterCasing.Normal, converter.SourceCasing);
Assert.Equal(CharacterCasing.Normal, converter.TargetCasing);
converter.Casing = CharacterCasing.Upper;
Assert.Equal(CharacterCasing.Upper, converter.SourceCasing);
Assert.Equal(CharacterCasing.Upper, converter.TargetCasing);
converter.Casing = CharacterCasing.Lower;
Assert.Equal(CharacterCasing.Lower, converter.SourceCasing);
Assert.Equal(CharacterCasing.Lower, converter.TargetCasing);
}
public void SetAliases(VaultStructureElements names, CaseConverter converter, UpdateBehaviour behaviour, bool dryRun)
{
var aliasUpdateBehaviour = behaviour.GetUpdateBehaviour();
if (names?.ObjectType != null)
{
UpdateObjTypeAliases(names.ObjectType, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.ValueList != null)
{
UpdateValueListAliases(names.ValueList, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.PropertyDef != null)
{
UpdatePropertyDefAliases(names.PropertyDef, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.Class != null)
{
UpdateClassAliases(names.Class, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.Workflow != null)
{
UpdateWorkflowAliases(names.Workflow, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.State != null)
{
UpdateStateAliases(names.State, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.StateTransition != null)
{
UpdateStateTransitionAliases(names.StateTransition, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.UserGroup != null)
{
UpdateUserGroupAliases(names.UserGroup, converter, aliasUpdateBehaviour, dryRun);
}
if (names?.NamedACL != null)
{
UpdateNamedACLAliases(names.NamedACL, converter, aliasUpdateBehaviour, dryRun);
}
}
public static string GetJobTitle(IEmployee employee, Sungero.Core.DeclensionCase declensionCase)
{
if (employee == null)
{
return(string.Empty);
}
if (employee.JobTitle == null)
{
return(string.Empty);
}
return(CaseConverter.ConvertJobTitleToTargetDeclension(employee.JobTitle.Name,
declensionCase));
}
public void casing_sets_both_source_casing_and_target_casing()
{
var converter = new CaseConverter();
Assert.Equal(CharacterCasing.Normal, converter.SourceCasing);
Assert.Equal(CharacterCasing.Normal, converter.TargetCasing);
converter.Casing = CharacterCasing.Upper;
Assert.Equal(CharacterCasing.Upper, converter.SourceCasing);
Assert.Equal(CharacterCasing.Upper, converter.TargetCasing);
converter.Casing = CharacterCasing.Lower;
Assert.Equal(CharacterCasing.Lower, converter.SourceCasing);
Assert.Equal(CharacterCasing.Lower, converter.TargetCasing);
}
public virtual void ChangeManyAddressees(Sungero.Domain.Client.ExecuteActionArgs e)
{
if (_obj.IsManyAddressees == false)
{
Dialogs.NotifyMessage(OutgoingDocumentBases.Resources.FillDistributionListOnAdressesTab);
}
if (_obj.IsManyAddressees == true && _obj.Addressees.Count(a => a.Correspondent != null) > 1)
{
var addresseeRaw = _obj.Addressees.OrderBy(a => a.Number).FirstOrDefault(a => a.Correspondent != null);
var addresseeName = string.Empty;
var correspondentName = addresseeRaw.Correspondent.Name;
if (addresseeRaw.Addressee != null)
{
if (addresseeRaw.Addressee.Person != null)
{
var person = addresseeRaw.Addressee.Person;
addresseeName = Parties.PublicFunctions.Person.GetSurnameAndInitialsInTenantCulture(person.FirstName, person.MiddleName, person.LastName);
}
else
{
var contactName = CaseConverter.SplitPersonFullName(addresseeRaw.Addressee.Name);
addresseeName = Parties.PublicFunctions.Person.GetSurnameAndInitialsInTenantCulture(contactName.FirstName, contactName.MiddleName, contactName.LastName);
}
addresseeName = string.Format("{0} ({1})", addresseeName, correspondentName);
}
else
{
addresseeName = correspondentName;
}
var dialog = Dialogs.CreateTaskDialog(OutgoingDocumentBases.Resources.ChangeManyAddresseesQuestion,
OutgoingDocumentBases.Resources.ChangeManyAddresseesDescriptionFormat(addresseeName), MessageType.Question);
dialog.Buttons.AddYesNo();
if (dialog.Show() == DialogButtons.Yes)
{
_obj.IsManyAddressees = !_obj.IsManyAddressees;
}
}
else
{
_obj.IsManyAddressees = !_obj.IsManyAddressees;
}
}
private static IEnumerable <Column> GetTableColumns(CaseConverter converter,
ObjectClass objClass, IEnumerable <PropertyDef> propertyDefs, bool ignoreBuiltinProperties)
{
var result = new List <Column>();
var asspciatedPropDefs = objClass.AssociatedPropertyDefs.Cast <AssociatedPropertyDef>();
foreach (var apd in asspciatedPropDefs)
{
var pd = propertyDefs.FirstOrDefault(p => p.ID == apd.PropertyDef);
if (pd is null || (ignoreBuiltinProperties && pd.Predefined))
{
continue;
}
var nullable = apd.Required ? "NOT NULL" : "NULL";
result.Add(new Column(converter.ToString(pd.Name), MapType(pd.DataType), !apd.Required));
}
return(result);
}
public void UpdateWorkflowAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new WorkflowNameParser(nameTemplate, converter);
var workflows = Vault.WorkflowOperations.GetWorkflowsAdmin()?.Cast <WorkflowAdmin>();
if (workflows == null)
{
return;
}
foreach (var workflow in workflows)
{
UpdateAlias(workflow,
(w) => Vault.WorkflowOperations.UpdateWorkflowAdmin(w),
parser,
behaviour,
workflow.SemanticAliases,
dryRun);
}
}
public void UpdatePropertyDefAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new PropertyDefNameParser(nameTemplate, converter);
var propDefs = Vault.PropertyDefOperations.GetPropertyDefsAdmin()?.Cast <PropertyDefAdmin>();
if (propDefs == null)
{
return;
}
foreach (var propDef in propDefs)
{
UpdateAlias(propDef,
(p) => Vault.PropertyDefOperations.UpdatePropertyDefAdmin(p),
parser,
behaviour,
propDef.SemanticAliases,
dryRun);
}
}
public void UpdateClassAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new ClassNameParser(nameTemplate, converter);
var classesAdmin = Vault.ClassOperations.GetAllObjectClassesAdmin()?.Cast <ObjectClassAdmin>();
if (classesAdmin == null)
{
return;
}
foreach (var classAdmin in classesAdmin)
{
UpdateAlias(classAdmin,
(ca) => UpdateClassAdmin(ca),
parser,
behaviour,
classAdmin.SemanticAliases,
dryRun);
}
}
public void UpdateUserGroupAliases(string nameTemplate, CaseConverter converter, IUpdateBehaviour behaviour, bool dryRun)
{
var parser = new UserGroupNameParser(nameTemplate, converter);
var groups = Vault.UserGroupOperations.GetUserGroupsAdmin()?.Cast <UserGroupAdmin>();
if (groups == null)
{
return;
}
foreach (var group in groups)
{
UpdateAlias(group,
(g) => Vault.UserGroupOperations.UpdateUserGroupAdmin(g),
parser,
behaviour,
group.SemanticAliases,
dryRun);
}
}
public void convert_back_uses_specified_culture_when_converting_to_upper_case()
{
var converter = new CaseConverter
{
SourceCasing = CharacterCasing.Upper
};
var cultureInfo = new CultureInfo("tr");
Assert.Equal("İJK", converter.ConvertBack("ijk", null, null, cultureInfo));
Assert.Equal("IJK", converter.ConvertBack("IJK", null, null, cultureInfo));
Assert.Equal("İJK", converter.ConvertBack("iJk", null, null, cultureInfo));
}
public void casing_throws_if_invalid_value_is_assigned()
{
var converter = new CaseConverter();
var ex = Assert.Throws<ArgumentException>(() => converter.Casing = (CharacterCasing)100);
Assert.Equal("Enum value '100' is not defined for enumeration 'System.Windows.Controls.CharacterCasing'.\r\nParameter name: value", ex.Message);
}
public void convert_return_unset_value_if_value_is_not_a_string()
{
var converter = new CaseConverter();
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(123, null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(123d, null, null, null));
Assert.Same(DependencyProperty.UnsetValue, converter.Convert(DateTime.Now, null, null, null));
}
public void convert_returns_same_value_if_target_casing_is_normal()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Normal
};
Assert.Equal("abcd", converter.Convert("abcd", null, null, null));
Assert.Equal("ABCD", converter.Convert("ABCD", null, null, null));
Assert.Equal("AbCd", converter.Convert("AbCd", null, null, null));
}
public void convert_back_returns_upper_cased_value_if_source_casing_is_upper()
{
var converter = new CaseConverter
{
SourceCasing = CharacterCasing.Upper
};
Assert.Equal("ABCD", converter.ConvertBack("abcd", null, null, null));
Assert.Equal("ABCD", converter.ConvertBack("ABCD", null, null, null));
Assert.Equal("ABCD", converter.ConvertBack("AbCd", null, null, null));
}
public void ctor_sets_source_casing_to_normal()
{
var converter = new CaseConverter();
Assert.Equal(CharacterCasing.Normal, converter.SourceCasing);
}
public void convert_returns_upper_cased_value_if_target_casing_is_upper()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Upper
};
Assert.Equal("ABCD", converter.Convert("abcd", null, null, null));
Assert.Equal("ABCD", converter.Convert("ABCD", null, null, null));
Assert.Equal("ABCD", converter.Convert("AbCd", null, null, null));
}
public void ctor_sets_target_casing_to_normal()
{
var converter = new CaseConverter();
Assert.Equal(CharacterCasing.Normal, converter.TargetCasing);
}
public void convert_uses_specified_culture_when_converting_to_lower_case()
{
var converter = new CaseConverter
{
TargetCasing = CharacterCasing.Lower
};
var cultureInfo = new CultureInfo("tr");
Assert.Equal("ijk", converter.Convert("ijk", null, null, cultureInfo));
Assert.Equal("ıjk", converter.Convert("IJK", null, null, cultureInfo));
Assert.Equal("ijk", converter.Convert("iJk", null, null, cultureInfo));
}
