public static ValueChangedSimple <ViewT> BindWrite <WidgetT, ViewT, DomainT>(this IReadWriteValueView <WidgetT, ViewT> view, IReadWriteValue <DomainT> domain, Func <ViewT, DomainT> convertToDomain)
{
ValueChangedSimple <ViewT> handler = async(newValue, userChange) => {
var value = RunConvertingExceptionToFailure(convertToDomain, newValue);
Logger.Debug(typeof(ValueViewExtensions), "BindWrite handler called with value after conversion={0}", value);
if (value.Success)
{
view.SetErrors(new HashSet <string>(), userChange);
view.IsValidating = true;
//await Task.Delay(5000); //testing only
try {
await domain.DoChange(value.Result, userChange);
} finally {
view.IsValidating = false;
}
}
else
{
view.SetErrors(new HashSet <string> {
value.ErrorMessage
}, userChange);
}
};
view.Changed += handler;
return(handler);
}
public RemoteValueChangeByEntryFormView(
IReadWriteValueView <HTMLElement, ViewT> input, TextType inputType = TextType.TreatAsText)
{
Input = input;
Message = new LabellessReadOnlyView("div", inputType);
Confirm = new InputTypeButtonActionView(I18n.Translate("OK"))
.With(x => x.MarkAsFormsDefaultButton());
}
public static LocalValue <T> Build <WidgetT, T>(
IReadWriteValueView <WidgetT, T> view, params Validate <T>[] validators)
{
var result = new LocalValue <T>(default(T), default(T));
view.BindReadWriteAndInitialize(result);
validators.ForEach(y => result.AddValidatorAndRevalidate(y));
return(result);
}
public static LocalValue <int?> BuildNullableIntBasedDropdown <WidgetT>(
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <int?>[] validators)
{
return(Build(null, view,
x => Tuple.Create(x.HasValue ? x.Value.ToString() : "", ""), //2nd param is irrelevant
x => string.IsNullOrEmpty(x?.Item1) ? (int?)null : Convert.ToInt32(x.Item1),
validators));
}
public static LocalValue <string> BuildStringBasedDropdown <WidgetT>(
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <string>[] validators)
{
return(Build(null, view,
x => Tuple.Create(x != null ? x : "", ""), //2nd param is irrelevant
x => string.IsNullOrEmpty(x?.Item1) ? null : x.Item1,
validators));
}
public ClassFieldRemoteMutator <int?, int?, ContT> BuildNullableIntBasedSelectDropdown <WidgetT>(
Expression <Func <ContT, int?> > getField, IReadWriteValueView <WidgetT, Tuple <string, string> > view,
params Validate <int?>[] validators)
{
return(Build(
getField, view,
x => Tuple.Create(!x.HasValue ? "" : x.Value.ToString(), ""),//second param is irrelevant
x => string.IsNullOrEmpty(x?.Item1) ? (int?)null : Convert.ToInt32(x.Item1),
validators));
}
//T should be enum but impossible to give such constraint. Using:
//http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
//but thrown out IConvertible doesn't seem to work in bridge.net
public static LocalValue <EnumT?> BuildNullableEnumBasedDropdown <WidgetT, EnumT>(
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <EnumT?>[] validators)
where EnumT : struct
{
return(Build(null, view,
x => Tuple.Create(x.ToString(), ""), //2nd param is irrelevant
x => string.IsNullOrEmpty(x.Item1) ? (EnumT?)null : (EnumT)(object)Convert.ToInt32(x.Item1),
validators));
}
public static LocalValue <ModelT> Build <WidgetT, ModelT, ViewT>(
ModelT defaultValue, IReadWriteValueView <WidgetT, ViewT> view,
Func <ModelT, ViewT> convertFromDomain, Func <ViewT, ModelT> convertToDomain,
params Validate <ModelT>[] validators)
{
var result = new LocalValue <ModelT>(defaultValue);
view.BindReadWriteAndInitialize(result, convertFromDomain, convertToDomain);
validators.ForEach(y => result.AddValidatorAndRevalidate(y));
return(result);
}
public static Tuple <ValueChangedRich <DomainT>, ValueChangedSimple <ViewT> > BindReadWriteAndInitialize <WidgetT, ViewT, DomainT>(
this IReadWriteValueView <WidgetT, ViewT> view, IReadWriteValue <DomainT> domain,
Func <DomainT, ViewT> convertFromDomain, Func <ViewT, DomainT> convertToDomain)
{
var readHandler = view.BindRead(domain, convertFromDomain);
var writeHandler = view.BindWrite(domain, convertToDomain);
readHandler(domain, domain.Value, domain.Value, domain.Errors, false);
Logger.Debug(typeof(ValueViewExtensions), "BindReadWriteAndInitialize current value = {0} errors={1}", domain.Value, domain.Errors.PrettyToString());
return(new Tuple <ValueChangedRich <DomainT>, ValueChangedSimple <ViewT> >(readHandler, writeHandler));
}
public static LocalValue <int> BuildIntBasedDropdown <WidgetT>(
int defaultValue,
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view,
params Validate <int>[] validators)
{
return(Build(defaultValue, view,
x => Tuple.Create(x.ToString(), ""), //2nd param is irrelevant
x => x.Item1 == "" ? -1 : Convert.ToInt32(x.Item1),
validators));
}
public static LocalValue <int?> BuildNullableInt <WidgetT>(
int?defaultValue, IReadWriteValueView <WidgetT, string> view,
params Validate <int?>[] validators)
{
var result = new LocalValue <int?>(defaultValue);
view.BindReadWriteAndInitialize(result,
x => !x.HasValue ? "" : I18n.Localize(x.Value),
x => string.IsNullOrEmpty(x) ? (int?)null : I18n.ParseInt(x));
validators.ForEach(y => result.AddValidatorAndRevalidate(y));
return(result);
}
/// <param name="domainToView">doesn't need to handle nulls/empty values</param>
/// <param name="viewToDomain">doesn't need to handle nulls/empty values</param>
public static LocalValue <DataT> BuildNullableDropdown <WidgetT, DataT>(
Func <DataT, string> domainToView,
Func <string, DataT> viewToDomain,
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <DataT>[] validators)
where DataT : class
{
return(Build(null, view,
x => Tuple.Create(x == null ? "" : domainToView(x), ""), //2nd param is irrelevant
x => string.IsNullOrEmpty(x.Item1) ? null : viewToDomain(x.Item1),
validators));
}
public ClassFieldRemoteMutator <DataT, DataT, ContT> Build <WidgetT, DataT>(
Expression <Func <ContT, DataT> > getField, IReadWriteValueView <WidgetT, DataT> view,
params Validate <DataT>[] validators)
{
return(new ClassFieldRemoteMutator <DataT, DataT, ContT>(
getField,
x => x,
x => x,
x => _caller.SaveField(ExpressionUtil.ExtractFieldName(getField), x),
x => {
validators.ForEach(y => x.AddValidatorAndRevalidate(y));
view.BindReadWriteAndInitialize(x);
},
postOperationConsumerOrNull: _postOperationConsumerOrNull,
postOperationInvokeBeforeChanged: _postOperationInvokeBeforeChanged));
}
public static RemoteValue <DataT, RemOperResT> Build <WidgetT, DataT, RemOperResT>(
DataT initialValue,
Func <DataT, Task <RemOperResT> > saveOper,
IReadWriteValueView <WidgetT, DataT> view,
Func <RemOperResT, DataT> remToLocal,
params Validate <DataT>[] validators)
{
return(new RemoteValue <DataT, RemOperResT>(
initialValue,
saveOper,
remToLocal,
initialization: x => {
validators.ForEach(x.AddValidatorAndRevalidate);
view.BindReadWriteAndInitialize(x);
}));
}
public static LocalValue <DataT> BuildChoice <WidgetT, DataT>(
DataT defaultVal,
Func <string, DataT> viewToDomain,
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <DataT>[] validators)
{
return(Build(defaultVal, view,
x => Tuple.Create(x.ToString(), ""), //2nd param is irrelevant
x => {
if (string.IsNullOrEmpty(x.Item1))
{
throw new Exception("cannot have null value in non nullable enum dropdown");
}
return viewToDomain(x.Item1);
},
validators));
}
public ClassFieldRemoteMutator <LocalT, RemT, ContT> BuildSingleChoiceDropDown <WidgetT, LocalT, RemT>(
Expression <Func <ContT, RemT> > getRemoteField, IReadWriteValueView <WidgetT, LocalT> view,
Func <LocalT, RemT> toRemoteType, Func <RemT, LocalT> toLocalType,
params Validate <LocalT>[] validators)
{
return(new ClassFieldRemoteMutator <LocalT, RemT, ContT>(
getRemoteField,
toRemoteType,
toLocalType,
x => _caller.SaveField(ExpressionUtil.ExtractFieldName(getRemoteField), x),
x => {
validators.ForEach(y => x.AddValidatorAndRevalidate(y));
view.BindReadWriteAndInitialize(x);
},
postOperationConsumerOrNull: _postOperationConsumerOrNull,
postOperationInvokeBeforeChanged: _postOperationInvokeBeforeChanged));
}
//T should be enum but impossible to give such constraint. Using:
//http://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum
//but thrown out IConvertible doesn't seem to work in bridge.net
public static LocalValue <EnumT> BuildEnumBasedChoice <WidgetT, EnumT>(
EnumT defaultVal,
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <EnumT>[] validators)
where EnumT : struct
{
return(Build(defaultVal, view,
x => Tuple.Create(x.ToString(), ""), //2nd param is irrelevant
x => {
if (string.IsNullOrEmpty(x.Item1))
{
throw new Exception("cannot have null value in non nullable enum dropdown");
}
return (EnumT)(object)Convert.ToInt32(x.Item1);
},
validators));
}
public static LocalValue <int> BuildInt <WidgetT>(
int defaultvalue, IReadWriteValueView <WidgetT, string> view, params Validate <int>[] validators)
{
var result = new LocalValue <int>(defaultvalue);
view.BindReadWriteAndInitialize(result, x => I18n.Localize(x), x => {
try {
var val = I18n.ParseInt(x);
return(val);
} catch (Exception ex) {
Logger.Error(typeof(LocalValueFieldBuilder), "BuildInt converter got exception {0}", ex);
throw new Exception(
I18n.Translate("Wrong integer format entered. Remove letters or special characters"));
}
});
validators.ForEach(y => result.AddValidatorAndRevalidate(y));
return(result);
}
public static LocalValue <T> BuildGeneralChoice <WidgetT, T>(
T defaultVal,
Func <int, T> intToItem,
Func <T, int> itemToInt,
// REVIEW: make view be of some new class or make it ValueTuple with element names
IReadWriteValueView <WidgetT, Tuple <string, string> > view, params Validate <T>[] validators)
{
return(Build(defaultVal, view,
x => Tuple.Create(itemToInt(x) + "", ""), //2nd param is irrelevant
x => {
if (string.IsNullOrEmpty(x.Item1))
{
throw new Exception("cannot have null value in non nullable enum dropdown");
}
return intToItem(Convert.ToInt32(x.Item1));
},
validators));
}
public static RemoteValue <LocalT, RemOperResT> Build <WidgetT, LocalT, RemOperResT, ViewT>(
LocalT initialValue,
Func <LocalT, Task <RemOperResT> > saveOper,
IReadWriteValueView <WidgetT, ViewT> view,
Func <RemOperResT, LocalT> remToLocal,
Func <LocalT, ViewT> convertFromDomain,
Func <ViewT, LocalT> convertToDomain,
params Validate <LocalT>[] validators)
{
return(new RemoteValue <LocalT, RemOperResT>(
initialValue,
saveOper,
remToLocal,
initialization: x => {
validators.ForEach(x.AddValidatorAndRevalidate);
view.BindReadWriteAndInitialize(x, convertFromDomain, convertToDomain);
}));
}
public RemoteValueChangeByEntryForm(
Func <DomainT, Task <RemoteT> > remoteChanger,
IReadWriteValueView <HTMLElement, ViewT> input,
Action <string> inputLabelChanger,
Func <DomainT, ViewT> domainToViewConverter,
Func <ViewT, DomainT> viewToDomainConverter,
string label, string titleOrNull = null,
DomainT defaultValue = default(DomainT),
TextType labelTextType = TextType.TreatAsText,
params Validate <DomainT>[] validators)
{
_inputLabelChanger = inputLabelChanger;
Title = titleOrNull ?? I18n.Translate("Input");
_view = new RemoteValueChangeByEntryFormView <ViewT>(input, labelTextType);
_inputLabelChanger(label);
_msg = new LocalValue <string>("");
_view.Message.BindReadOnlyAndInitialize(_msg);
_input = LocalValueFieldBuilder.Build(
defaultValue, _view.Input, domainToViewConverter, viewToDomainConverter, validators);
var isFormValid = new AggregatedErrorsValue <bool>(
false, x => !x.Errors.Any(), x => x.Observes(_input));
var confirmInput = RemoteActionBuilder.Build(
_view.Confirm,
() => remoteChanger(_input.Value),
x => {
SavedValue = x;
Ended?.Invoke(this, CompletedOrCanceled.Completed);
});
confirmInput.BindEnableAndInitialize(isFormValid);
}
public static LocalValue <int> BuildInt <WidgetT>(
IReadWriteValueView <WidgetT, string> view, params Validate <int>[] validators)
{
return(BuildInt(0, view, validators));
}
public ClassFieldRemoteMutator <int, int, ContT> BuildInt <WidgetT>(
Expression <Func <ContT, int> > getField, IReadWriteValueView <WidgetT, string> view,
params Validate <int>[] validators)
{
return(Build(getField, view, x => I18n.Localize(x), x => I18n.ParseInt(x), validators));
}
public static Tuple <ValueChangedRich <T>, ValueChangedSimple <T> > BindReadWriteAndInitialize <WidgetT, T>(
this IReadWriteValueView <WidgetT, T> view, IReadWriteValue <T> domain)
{
return(view.BindReadWriteAndInitialize(domain, x => x, x => x));
}
public static ValueChangedSimple <T> BindWrite <WidgetT, T>(
this IReadWriteValueView <WidgetT, T> view, IReadWriteValue <T> domain)
{
return(view.BindWrite(domain, x => x));
}
