/// <summary>
/// Edits the contexts for result row.
/// </summary>
/// <param name="resultRow">The result row.</param>
/// <param name="tabConfig">The tab configuration.</param>
/// <param name="editFieldDictionary">The edit field dictionary.</param>
/// <param name="initialValues">The initial values.</param>
/// <param name="fieldPostfix">The field postfix.</param>
/// <param name="initialRecords">The initial records.</param>
/// <returns></returns>
public List <object> EditContextsForResultRow(UPCRMResultRow resultRow, FieldControlTab tabConfig,
Dictionary <string, UPEditFieldContext> editFieldDictionary, Dictionary <string, object> initialValues, string fieldPostfix, List <UPCRMRecord> initialRecords)
{
var recordIdentification = resultRow?.RecordIdentificationAtIndex(0);
var fieldArray = new List <object>();
UPCRMRecord offlineRootRecord = null;
if (initialRecords?.Count > 0)
{
offlineRootRecord = initialRecords.FirstOrDefault();
}
var identifierPrefix = recordIdentification;
if (string.IsNullOrEmpty(identifierPrefix))
{
identifierPrefix = $"{this.TabConfig.FieldControl.UnitName}_{this.TabIndex}";
}
var fieldCount = tabConfig?.NumberOfFields ?? 0;
for (var j = 0; j < fieldCount; j++)
{
var fieldConfig = tabConfig?.FieldAtIndex(j);
if (fieldConfig == null)
{
continue;
}
var fieldAttributes = fieldConfig.Attributes;
var currentInfoAreaId = fieldConfig.InfoAreaId;
var currentLinkId = fieldConfig.LinkId;
var fieldIdentifier = FieldIdentifier.IdentifierWithRecordIdentificationFieldId(identifierPrefix, fieldConfig.Identification);
UPSelector selector = null;
var selectorDef = fieldConfig.Attributes?.Selector;
if (selectorDef != null)
{
var filterParameters = this.EditPageContext?.ViewReference?.ContextValueForKey("copyFields")?.JsonDictionaryFromString();
if (resultRow?.Result != null && resultRow.IsNewRow)
{
selector = UPSelector.SelectorFor(
resultRow.RootRecordIdentification?.InfoAreaId(),
resultRow.Result.ParentRecordIdentification,
resultRow.Result.LinkId,
selectorDef,
filterParameters,
fieldConfig);
}
else
{
selector = UPSelector.SelectorFor(resultRow?.RootRecordIdentification, selectorDef, filterParameters, fieldConfig);
}
selector.Build();
if (selector.OptionCount == 0 && selector.IsStaticSelector)
{
selector = null;
}
}
var isEditField = this.enableLinkedEditFields ||
selector != null ||
(tabConfig.FieldControl.InfoAreaId == currentInfoAreaId && currentLinkId <= 0);
var isHidden = fieldAttributes.Hide;
var isReadOnly = isEditField && fieldAttributes.ReadOnly;
var rawFieldValue0 = resultRow?.RawValueAtIndex(fieldConfig.TabIndependentFieldIndex);
var fieldInfo = fieldConfig.Field.FieldInfo;
if (isEditField && !isReadOnly && !(selector is UPRecordSelector && ((UPRecordSelector)selector).IgnoreFieldInfo))
{
if (fieldInfo.IsReadOnly)
{
isReadOnly = true;
}
else if (resultRow?.IsNewRow == true || string.IsNullOrEmpty(rawFieldValue0))
{
if (fieldInfo.LockedOnNew)
{
isReadOnly = true;
}
}
else if (fieldInfo.LockedOnUpdate && !fieldInfo.IsEmptyValue(rawFieldValue0))
{
isReadOnly = true;
}
}
string offlineValue = null;
bool offlineChanged;
string rawFieldValue;
UPEditFieldContext editFieldContext;
if (isEditField)
{
List <UPEditFieldContext> childFields = null;
if (fieldAttributes.FieldCount > 1 && selector == null)
{
childFields = new List <UPEditFieldContext>();
for (var k = 1; k < fieldAttributes.FieldCount; k++)
{
var childFieldConfig = tabConfig.FieldAtIndex(++j);
if (childFieldConfig != null)
{
rawFieldValue = resultRow.RawValueAtIndex(childFieldConfig.TabIndependentFieldIndex);
if (initialValues != null)
{
rawFieldValue = this.ValueByApplyingInitialValuesForField(rawFieldValue, childFieldConfig, initialValues);
}
offlineChanged = false;
if (offlineRootRecord != null)
{
offlineValue = offlineRootRecord.StringFieldValueForFieldIndex(childFieldConfig.FieldId);
if (offlineValue != null && !offlineValue.Equals(rawFieldValue))
{
offlineChanged = true;
}
}
editFieldContext = UPEditFieldContext.ChildFieldContextForFieldConfigValue(childFieldConfig, rawFieldValue);
if (offlineChanged)
{
editFieldContext.SetOfflineChangeValue(offlineValue);
}
childFields.Add(editFieldContext);
}
}
}
var markAsChanged = false;
rawFieldValue = rawFieldValue0;
if (initialValues != null)
{
string initialValue = this.ValueByApplyingInitialValuesForField(rawFieldValue, fieldConfig, initialValues);
if (!rawFieldValue.Equals(initialValue))
{
markAsChanged = true;
rawFieldValue = initialValue;
}
}
offlineChanged = false;
offlineValue = null;
if (offlineRootRecord != null)
{
offlineValue = offlineRootRecord.StringFieldValueForFieldIndex(fieldConfig.FieldId);
if (offlineValue != null && !offlineValue.Equals(rawFieldValue))
{
offlineChanged = true;
}
}
if (selector != null)
{
// Sometimes it makes sense to add the Link field , so you have the link information on the EditPage , but the field is not displayed .
// Thus, the field is interpreted as EditField Selector must be set.
if (isHidden)
{
editFieldContext = UPEditFieldContext.HiddenFieldFor(fieldConfig, fieldIdentifier, rawFieldValue);
}
else if (isReadOnly && ConfigurationUnitStore.DefaultStore.ConfigValueIsSet("Disable.82213"))
{
editFieldContext = UPEditFieldContext.ReadonlyFieldFor(fieldConfig, fieldIdentifier, rawFieldValue);
}
else
{
editFieldContext = UPEditFieldContext.FieldContextFor(fieldConfig, fieldIdentifier, rawFieldValue, selector);
}
}
else
{
if (isHidden)
{
editFieldContext = UPEditFieldContext.HiddenFieldFor(fieldConfig, fieldIdentifier, rawFieldValue);
}
else if (isReadOnly)
{
editFieldContext = UPEditFieldContext.ReadonlyFieldFor(fieldConfig, fieldIdentifier, rawFieldValue);
}
else
{
editFieldContext = UPEditFieldContext.FieldContextFor(fieldConfig, fieldIdentifier, rawFieldValue, childFields as List <UPEditFieldContext>);
}
}
if (fieldInfo.DateFieldId >= 0 && tabConfig.FieldControl.InfoAreaId == currentInfoAreaId)
{
editFieldContext.DateOriginalValue = resultRow?.RawValueForFieldIdInfoAreaIdLinkId(fieldInfo.DateFieldId, currentInfoAreaId, -1);
}
else if (fieldInfo.TimeFieldId >= 0 && tabConfig.FieldControl.InfoAreaId == currentInfoAreaId)
{
editFieldContext.TimeOriginalValue = resultRow?.RawValueForFieldIdInfoAreaIdLinkId(fieldInfo.TimeFieldId, currentInfoAreaId, -1);
}
if (offlineChanged)
{
editFieldContext.SetOfflineChangeValue(offlineValue);
}
else if (markAsChanged)
{
editFieldContext.SetChanged(true);
}
if (editFieldContext != null)
{
if (!string.IsNullOrEmpty(fieldPostfix))
{
editFieldContext.FieldLabelPostfix = fieldPostfix;
}
if (editFieldDictionary != null)
{
editFieldDictionary.SetObjectForKey(editFieldContext, fieldConfig.Identification);
if (childFields != null)
{
foreach (var childFieldContext in childFields)
{
editFieldDictionary.SetObjectForKey(childFieldContext, childFieldContext.FieldConfig.Identification);
}
}
}
fieldArray.Add(editFieldContext);
}
}
else
{
string fieldValue;
if (fieldAttributes.FieldCount > 1)
{
fieldValue = resultRow?.ValueAtIndex(fieldConfig.TabIndependentFieldIndex);
if (string.IsNullOrEmpty(fieldValue))
{
fieldValue = this.ValueForLinkFieldFromInitialValues(fieldConfig, initialValues);
}
var values = !string.IsNullOrEmpty(fieldValue) ?
new List <string> {
fieldValue
} :
new List <string>();
for (var k = 1; k < fieldAttributes.FieldCount; k++)
{
var childfieldConfig = tabConfig.FieldAtIndex(++j);
if (childfieldConfig == null)
{
continue;
}
fieldValue = resultRow?.ValueAtIndex(childfieldConfig.TabIndependentFieldIndex);
if (string.IsNullOrEmpty(fieldValue))
{
fieldValue = this.ValueForLinkFieldFromInitialValues(childfieldConfig, initialValues);
}
if (string.IsNullOrEmpty(fieldValue))
{
fieldValue = string.Empty;
}
values.Add(fieldValue);
}
fieldValue = fieldAttributes.FormatValues(values);
}
else
{
fieldValue = resultRow?.ValueAtIndex(fieldConfig.TabIndependentFieldIndex);
if (string.IsNullOrEmpty(fieldValue))
{
fieldValue = this.ValueForLinkFieldFromInitialValues(fieldConfig, initialValues);
}
}
UPMField field;
if (!isHidden && !string.IsNullOrEmpty(fieldValue))
{
field = new UPMStringField(fieldIdentifier);
((UPMStringField)field).StringValue = fieldValue;
}
else
{
field = null;
}
if (field != null)
{
if (!fieldConfig.Attributes.NoLabel)
{
field.LabelText = fieldConfig.Label;
}
SetAttributesOnField(fieldAttributes, field);
fieldArray.Add(field);
}
}
}
return(fieldArray);
}
protected override void OnInitialized()
{
_fieldIdentifier = FieldIdentifier.Create(ValueExpression);
}
private static UPMPhoneField CreatePhoneField(FieldAttributes fieldAttributes, FieldIdentifier fieldIdentifier)
{
var field = new UPMPhoneField(fieldIdentifier);
var phoneInExtendedOptions = fieldAttributes.ExtendedOptions.ValueOrDefault("phone");
if (phoneInExtendedOptions != null)
{
field.UseTelprompt = phoneInExtendedOptions == "telprompt";
}
return(field);
}
private UPMGroup AddFieldsToDetailGroup(UPMGroup upmGroup, string recordIdentification, UPCRMResultRow resultRow, out string documentKey, out UPConfigFieldControlField documentFieldConfig)
{
var configStore = ConfigurationUnitStore.DefaultStore;
var hideEmptyFields = configStore.ConfigValueIsSet("View.HideEmptyFields");
documentKey = string.Empty;
documentFieldConfig = null;
var listFormatter = new UPCRMListFormatter(this.TabConfig, false);
var fieldCount = listFormatter.PositionCount;
var detailGroup = upmGroup;
for (var j = 0; j < fieldCount; j++)
{
var fieldConfig = listFormatter.FirstFieldForPosition(j);
var fieldAttributes = fieldConfig.Attributes;
var fieldIdentifier = FieldIdentifier.IdentifierWithRecordIdentificationFieldId(recordIdentification, fieldConfig.Identification);
var hasFieldValue = false;
if (fieldAttributes.Image)
{
documentKey = resultRow.ValueAtIndex(fieldConfig.TabIndependentFieldIndex);
documentFieldConfig = fieldConfig;
if (!string.IsNullOrEmpty(documentKey) && fieldCount == 1)
{
detailGroup = this.AddFieldToDetailGroup(detailGroup, fieldIdentifier, recordIdentification);
}
continue;
}
if (fieldAttributes.Hide)
{
continue;
}
if (fieldAttributes.Empty)
{
detailGroup = this.AddFieldToDetailGroup(detailGroup, recordIdentification, fieldIdentifier, fieldAttributes);
continue;
}
string fieldValue = null;
try
{
fieldValue = listFormatter.StringFromRowForPosition(resultRow, j);
}
catch (Exception error)
{
SimpleIoc.Default.GetInstance <ILogger>().LogError(error);
}
if (!string.IsNullOrEmpty(fieldValue))
{
hasFieldValue = true;
}
if (!hasFieldValue && hideEmptyFields && !this.columnStyle)
{
if (!(detailGroup is UPMCalendarPopoverGroup) || j > 3)
{
continue;
}
}
if (fieldAttributes.MultiLine && j + 1 == fieldCount && detailGroup == null)
{
var multiLineGroup = this.CreateMultilineGroup(recordIdentification, CreateStringField(fieldIdentifier, fieldAttributes, fieldValue), fieldConfig);
this.ControllerState = GroupModelControllerState.Finished;
this.Group = multiLineGroup;
return(multiLineGroup);
}
var field = this.CreateField(fieldAttributes, fieldIdentifier, fieldConfig, resultRow, recordIdentification, configStore);
if (field == null)
{
continue;
}
UpdateField(field, fieldAttributes, fieldConfig, fieldValue);
if (string.IsNullOrWhiteSpace(field.LabelText) && string.IsNullOrEmpty(fieldValue))
{
continue;
}
detailGroup = this.AddFieldToDetailGroup(detailGroup, fieldAttributes, field, recordIdentification);
}
return(detailGroup);
}
/// <summary> /// Gets a string that indicates the status of the specified field as a CSS class. This will include /// some combination of "modified", "valid", or "invalid", depending on the status of the field. /// </summary> /// <param name="editContext">The <see cref="EditContext"/>.</param> /// <param name="accessor">An identifier for the field.</param> /// <returns>A string that indicates the status of the field.</returns> public static string FieldCssClass <TField>(this EditContext editContext, Expression <Func <TField> > accessor) => FieldCssClass(editContext, FieldIdentifier.Create(accessor));
/// <summary> /// Adds the message and apply it to the field identifier. /// </summary> /// <param name="fieldIdentifier">Field identifier to which messages belong.</param> /// <param name="message">Message result.</param> public void Add(FieldIdentifier fieldIdentifier, ValidationMessageResult message) => GetOrCreateMessagesListForField(fieldIdentifier).Add(message);
public void AddError(FieldIdentifier field, string errMessage)
{
_messageStore.Add(field, errMessage);
}
private string GetColumnAttributeStr (int column, FieldIdentifier fieldId)
{
OdbcReturn ret = OdbcReturn.Error;
byte [] buffer = new byte [255];
short outsize = 0;
int val = 0;
ret = libodbc.SQLColAttribute (hstmt, (short)column, fieldId,
buffer, (short)buffer.Length,
ref outsize, ref val);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw Connection.CreateOdbcException (
OdbcHandleType.Stmt, hstmt);
string value = string.Empty;
if (outsize > 0)
value = Encoding.Unicode.GetString (buffer, 0, outsize);
return value;
}
public void ClearError(FieldIdentifier fieldIdentifier)
{
_validationMessageStore.Clear(fieldIdentifier);
EditContext.NotifyValidationStateChanged();
}
protected override void OnInit()
{
if (CurrentEditContext == null)
{
throw new InvalidOperationException($"{nameof(FluentValidationValidator)} requires a cascading " +
$"parameter of type {nameof(EditContext)}. For example, you can use {nameof(FluentValidationValidator)} " +
$"inside an {nameof(EditForm)}.");
}
var validator = Validator ?? GetValidatorForModel(CurrentEditContext.Model);
if (validator == null)
{
throw new InvalidOperationException($"{nameof(FluentValidationValidator)} requires either a " +
$"parameter of type {nameof(IValidator)}, or validator for type {nameof(CurrentEditContext.Model)} " +
$"should be reachable via reflection from the calling assembly.");
}
var messages = new ValidationMessageStore(CurrentEditContext);
var modelName = CurrentEditContext.Model.GetType().FullName;
// This field collects errors that are model-related but not specific to concrete property on the model
var modelErrorField = new FieldIdentifier(CurrentEditContext.Model, string.Empty);
var _event = _eventAggregator?.GetEvent <ValidationEvent>();
// This subscription fires when Submit button is pressed,
// acts as a guard against not validated still-focused field
formValidationSub = Observable.FromEventPattern <ValidationRequestedEventArgs>(
handler => CurrentEditContext.OnValidationRequested += handler,
handler => CurrentEditContext.OnValidationRequested -= handler)
.Subscribe(e =>
{
messages.Clear();
var validationResults = validator.Validate(CurrentEditContext.Model);
if (validationResults.IsValid)
{
_event?.Publish(new ValidationEventArgs(true, modelName));
if (OnValidation.HasDelegate)
{
OnValidation.InvokeAsync(true);
}
}
else
{
_event?.Publish(new ValidationEventArgs(false, modelName));
if (OnValidation.HasDelegate)
{
OnValidation.InvokeAsync(false);
}
foreach (var validationResult in validationResults.Errors)
{
messages.Add(CurrentEditContext.Field(validationResult.PropertyName), validationResult.ErrorMessage);
}
}
CurrentEditContext.NotifyValidationStateChanged();
});
// This subscription fires every time an input field loses a focus, main workhorse
fieldValidationSub = Observable.FromEventPattern <FieldChangedEventArgs>(
handler => CurrentEditContext.OnFieldChanged += handler,
handler => CurrentEditContext.OnFieldChanged -= handler)
.Subscribe(e =>
{
var validationResults = validator.Validate(CurrentEditContext.Model);
if (validationResults.IsValid)
{
messages.Clear();
_event?.Publish(new ValidationEventArgs(true, modelName));
if (OnValidation.HasDelegate)
{
OnValidation.InvokeAsync(true);
}
}
else
{
_event?.Publish(new ValidationEventArgs(false, modelName));
if (OnValidation.HasDelegate)
{
OnValidation.InvokeAsync(false);
}
messages.Clear(e.EventArgs.FieldIdentifier);
messages.AddRange(e.EventArgs.FieldIdentifier, validationResults.Errors
.Where(failure => failure.PropertyName == e.EventArgs.FieldIdentifier.FieldName)
.Select(failure => failure.ErrorMessage));
// add errors that are not specific to field, e.g. complex rules
messages.Clear(modelErrorField);
messages.AddRange(modelErrorField, validationResults.Errors
.Where(failure => failure.PropertyName == string.Empty)
.Select(failure => failure.ErrorMessage));
}
CurrentEditContext.NotifyValidationStateChanged();
});
}
public void Visit(FieldIdentifier f)
{
this.Translated = $"{f.Identifier}()";
}
/// <summary>
/// Initializes a new instance of <see cref="FormFieldChangedEventArgs"/>
/// </summary>
/// <param name="isValid">true if the form is currently valid; otherwise, false.</param>
/// <param name="fieldIdentifier">The field whose value has changed.</param>
public FormFieldChangedEventArgs(bool isValid, FieldIdentifier fieldIdentifier)
{
IsValid = isValid;
Field = fieldIdentifier;
}
public static Field Unresolved(FieldIdentifier fieldIdentifier, DeclaredType type, IReferencable returnType)
{
return new Field(fieldIdentifier, type) { IsResolved = false, ReturnType = returnType };
}
/// <summary> /// 获取显示名称方法 /// </summary> /// <param name="fieldIdentifier"></param> /// <returns></returns> public static string GetDisplayName(this FieldIdentifier fieldIdentifier) => Utility.GetDisplayName(fieldIdentifier.Model, fieldIdentifier.FieldName);
/// <summary>
/// Adds an error message to the message store but without notification for display.
/// This enables adding multiple messages, e.g. from a foreach loop
/// </summary>
/// <param name="model"></param>
/// <param name="fieldName"></param>
/// <param name="errMessage"></param>
public void AddErrorNoNotify(object model, string fieldName, string errMessage)
{
var field = new FieldIdentifier(model, fieldName);
_messageStore.Add(field, errMessage);
}
protected override void OnParametersSet()
{
base.OnParametersSet();
_fieldIdentifier = base.FieldIdentifier;
}
public static NodeDevice StaticBuildHelper(string deviceName, int serialNumber, string code, string typeId,
int discreteInputs, int discreteOutputs, int analogInputs, int analogOutputs, int stringInputs, int stringOutputs,
string analogOutputNameOverride, string discreteOutputNameOverride)
{
FieldIdentifier c;
FieldGuid typ;
FieldString address;
FieldBase64 configuration;
FieldDeviceName dName;
c = new FieldIdentifier(code);
typ = new FieldGuid(typeId);
address = new FieldString(serialNumber.ToString());
configuration = new FieldBase64(string.Empty);
dName = new FieldDeviceName(deviceName);
NodeDevice device = NodeDevice.BuildWith(c, typ, address, configuration, dName);
// Add the inputs
var inputsMutable = new Collection <NodeDiscreteInput>();
for (int i = 0; i < discreteInputs; i++)
{
inputsMutable.Add(NodeDiscreteInput.BuildWith(
new FieldIdentifier(Resources.Strings.Input + i),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.Input + " " + i)));
}
var inputs = new ReadOnlyCollection <NodeDiscreteInput>(inputsMutable);
device = device.NodeDiscreteInputChildren.Append(inputs);
var analogInputsMutable = new Collection <NodeAnalogInput>();
for (int i = 0; i < analogInputs; i++)
{
analogInputsMutable.Add(NodeAnalogInput.BuildWith(
new FieldIdentifier(Resources.Strings.AnalogInput + i),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.AnalogInput + " " + i)));
}
device = device.NodeAnalogInputChildren.Append(new ReadOnlyCollection <NodeAnalogInput>(analogInputsMutable));
var stringInputsMutable = new Collection <NodeStringInput>();
for (int i = 0; i < stringInputs; i++)
{
stringInputsMutable.Add(NodeStringInput.BuildWith(
new FieldIdentifier(Resources.Strings.StringInput + i),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.StringInput + " " + i)));
}
device = device.NodeStringInputChildren.Append(new ReadOnlyCollection <NodeStringInput>(stringInputsMutable));
// Add the outputs
var outputsMutable = new Collection <NodeDiscreteOutput>();
for (int i = 0; i < discreteOutputs; i++)
{
outputsMutable.Add(NodeDiscreteOutput.BuildWith(
new FieldIdentifier(Resources.Strings.Output + i),
new FieldString(i.ToString()),
new FieldSignalName(discreteOutputNameOverride + " " + i)));
}
var outputs = new ReadOnlyCollection <NodeDiscreteOutput>(outputsMutable);
device = device.NodeDiscreteOutputChildren.Append(outputs);
var analogOutputsMutable = new Collection <NodeAnalogOutput>();
for (int i = 0; i < analogOutputs; i++)
{
analogOutputsMutable.Add(NodeAnalogOutput.BuildWith(
new FieldIdentifier(Resources.Strings.AnalogOutput + i),
new FieldString(i.ToString()),
new FieldSignalName(analogOutputNameOverride + " " + i)));
}
device = device.NodeAnalogOutputChildren.Append(new ReadOnlyCollection <NodeAnalogOutput>(analogOutputsMutable));
var stringOutputsMutable = new Collection <NodeStringOutput>();
for (int i = 0; i < stringOutputs; i++)
{
stringOutputsMutable.Add(NodeStringOutput.BuildWith(
new FieldIdentifier(Resources.Strings.StringOutput + i),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.StringOutput + " " + i)));
}
device = device.NodeStringOutputChildren.Append(new ReadOnlyCollection <NodeStringOutput>(stringOutputsMutable));
return(device);
}
public static Field Unresolved(FieldIdentifier fieldIdentifier, DeclaredType type)
{
return new Field(fieldIdentifier, type) { IsResolved = false };
}
protected virtual Type GetEntityType(FieldIdentifier identifier)
{
return(identifier.Model.GetType());
}
/// <summary> /// Clears the messages for the supplied <see cref="FieldIdentifier"/>. /// </summary> /// <param name="fieldIdentifier">Field identifier to which messages belong.</param> public void Clear(FieldIdentifier fieldIdentifier) => messages.Remove(fieldIdentifier);
protected virtual IEntityId GetEntityModel(FieldIdentifier identifier)
{
return(identifier.Model as IEntityId);
}
/// <summary> /// Adds the list of messages and apply it to the field identifier. /// </summary> /// <param name="fieldIdentifier">Field identifier to which messages belong.</param> /// <param name="messages"></param> public void Add(FieldIdentifier fieldIdentifier, IEnumerable <ValidationMessageResult> messages) => GetOrCreateMessagesListForField(fieldIdentifier).AddRange(messages);
public FieldInstructionType(FieldIdentifier language, FieldIdentifier library, FieldIdentifier code)
: base(
language.ToString() + SEPARATOR +
library.ToString() + SEPARATOR +
code.ToString())
{
m_Language = language;
m_Library = library;
m_Code = code;
}
private static UPMStringField CreateStringField(FieldAttributes fieldAttributes, FieldIdentifier fieldIdentifier)
{
UPMStringField field;
var phoneInExtendedOptions = fieldAttributes?.ExtendedOptions?.ValueOrDefault("phone");
if (phoneInExtendedOptions != null)
{
field = new UPMPhoneField(fieldIdentifier);
((UPMPhoneField)field).UseTelprompt = phoneInExtendedOptions == "telprompt";
}
else
{
field = new UPMStringField(fieldIdentifier);
}
return(field);
}
public static NodeDevice StaticBuildHelper(string deviceName, string typeId, Guid instanceId, string code,
int buttons, int axes, int povhats)
{
FieldIdentifier c;
FieldGuid typ;
FieldString address;
FieldBase64 configuration;
FieldDeviceName dName;
c = new FieldIdentifier(code);
typ = new FieldGuid(typeId);
address = new FieldString(instanceId.ToString());
configuration = new FieldBase64(string.Empty);
dName = new FieldDeviceName(deviceName);
NodeDevice device = NodeDevice.BuildWith(c, typ, address, configuration, dName);
// Add the inputs
var inputsMutable = new Collection <NodeDiscreteInput>();
for (int i = 0; i < buttons; i++)
{
int buttonNumber = i + 1;
inputsMutable.Add(NodeDiscreteInput.BuildWith(
new FieldIdentifier(Resources.Strings.Button + buttonNumber),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.Button + " " + buttonNumber)));
}
var inputs = new ReadOnlyCollection <NodeDiscreteInput>(inputsMutable);
device = device.NodeDiscreteInputChildren.Append(inputs);
var analogInputsMutable = new Collection <NodeAnalogInput>();
for (int i = 0; i < axes; i++)
{
if (i == 3)
{
break; // only supports up to 3 axes
}
int axisNumber = i + 1;
string axisName =
axisNumber == 1 ? "X" :
axisNumber == 2 ? "Y" :
axisNumber == 3 ? "Z" :
null;
analogInputsMutable.Add(NodeAnalogInput.BuildWith(
new FieldIdentifier(axisName),
new FieldString(axisName),
new FieldSignalName(axisName)));
string rotationName = "Rotation" + axisName;
analogInputsMutable.Add(NodeAnalogInput.BuildWith(
new FieldIdentifier(rotationName),
new FieldString(rotationName),
new FieldSignalName(rotationName)));
}
for (int i = 0; i < povhats; i++)
{
int povNumber = i + 1;
analogInputsMutable.Add(NodeAnalogInput.BuildWith(
new FieldIdentifier(Resources.Strings.PoVHat + povNumber.ToString()),
new FieldString(i.ToString()),
new FieldSignalName(Resources.Strings.PoVHat + " " + povNumber.ToString())));
}
device = device.NodeAnalogInputChildren.Append(new ReadOnlyCollection <NodeAnalogInput>(analogInputsMutable));
return(device);
}
private UPMGroup AddFieldToDetailGroup(UPMGroup detailGroup, string recordIdentification, FieldIdentifier fieldIdentifier, FieldAttributes fieldAttributes)
{
if (detailGroup == null)
{
detailGroup = new UPMStandardGroup(this.TabIdentifierForRecordIdentification(recordIdentification));
((UPMStandardGroup)detailGroup).ColumnStyle = this.columnStyle;
detailGroup.LabelText = this.TabLabel;
}
var field = new UPMStringField(fieldIdentifier)
{
StripNewLines = fieldAttributes.NoMultiLine
};
detailGroup.AddField(field);
return(detailGroup);
}
public void CanUseEmptyFieldName()
{
var fieldIdentifier = new FieldIdentifier(new object(), string.Empty);
Assert.Equal(string.Empty, fieldIdentifier.FieldName);
}
/// <summary>
///
/// </summary>
protected override void OnInitialized()
{
EditForm?.AddValidator((EditForm, FieldIdentifier.Model.GetType(), FieldIdentifier.FieldName), this);
DisplayName = FieldIdentifier.GetDisplayName();
}
private string GetColumnAttributeStr (int column, FieldIdentifier fieldId)
{
OdbcReturn ret = OdbcReturn.Error;
byte [] buffer = new byte [255];
int outsize = 0;
int val = 0;
ret = libodbc.SQLColAttribute (hstmt, column, fieldId,
buffer, buffer.Length,
ref outsize, ref val);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw new OdbcException (new OdbcError ("SQLColAttribute",
OdbcHandleType.Stmt,
hstmt)
);
string value = "";
if (outsize > 0)
value = Encoding.Default.GetString (buffer, 0, outsize);
return value;
}
private static async void ValidatField(EditContext editContext, ValidationMessageStore message, FieldIdentifier fieldIdentifier, IServiceProvider serviceProvider, IValidator validator = null)
{
var Proparties = new[] { fieldIdentifier.FieldName };
var Context = new ValidationContext(fieldIdentifier.Model, new PropertyChain(), new MemberNameValidatorSelector(Proparties));
validator = validator ?? GetValidatorForModel(serviceProvider, fieldIdentifier.Model);
if (validator != null)
{
var ValidationResults = await validator.ValidateAsync(Context);
message.Clear(fieldIdentifier);
message.Add(fieldIdentifier, ValidationResults.Errors.Select(e => e.ErrorMessage));
editContext.NotifyValidationStateChanged();
}
}
private static async void ValidateField(EditContext editContext, ValidationMessageStore messages, FieldIdentifier fieldIdentifier, IServiceProvider serviceProvider, IValidator validator = null)
{
var properties = new[] { fieldIdentifier.FieldName };
var context = new ValidationContext(fieldIdentifier.Model, new PropertyChain(), new MemberNameValidatorSelector(properties));
if (validator == null)
{
validator = GetValidatorForModel(serviceProvider, editContext.Model);
}
var validationResults = await validator.ValidateAsync(context);
messages.Clear(fieldIdentifier);
messages.AddRange(fieldIdentifier, validationResults.Errors.Select(error => error.ErrorMessage));
editContext.NotifyValidationStateChanged();
}
/// <summary> /// 获取 PlaceHolder 方法 /// </summary> /// <param name="fieldIdentifier"></param> /// <returns></returns> public static string?GetPlaceHolder(this FieldIdentifier fieldIdentifier) => Utility.GetPlaceHolder(fieldIdentifier.Model, fieldIdentifier.FieldName);
public static T GetValue <T>(this FieldIdentifier fi)
{
var prop = fi.Model.GetType().GetProperty(fi.FieldName);
return((T)prop.GetValue(fi.Model));
}
private int GetColumnAttribute (int column, FieldIdentifier fieldId)
{
OdbcReturn ret = OdbcReturn.Error;
byte [] buffer = new byte [255];
short outsize = 0;
int val = 0;
ret = libodbc.SQLColAttribute (hstmt, (short)column, fieldId,
buffer, (short)buffer.Length,
ref outsize, ref val);
if (ret != OdbcReturn.Success && ret != OdbcReturn.SuccessWithInfo)
throw Connection.CreateOdbcException (
OdbcHandleType.Stmt, hstmt);
return val;
}
private void ClearPreviousParsingMessage(ref bool previousParsingAttemptFailed, FieldIdentifier fieldIdentifier)
{
if (previousParsingAttemptFailed)
{
previousParsingAttemptFailed = false;
validationMessageStore.Clear(fieldIdentifier);
EditContext.NotifyValidationStateChanged();
}
}
internal static extern OdbcReturn SQLColAttribute ( IntPtr StmtHandle, short column, FieldIdentifier fieldId, byte [] charAttributePtr, short bufferLength, ref short strLengthPtr, ref int numericAttributePtr);
/// <summary>
/// Initializes a new instance of the <see cref="Field"/> class.
/// </summary>
/// <param name="identifier">
/// The identifier.
/// </param>
/// <param name="type">
/// The type.
/// </param>
public Field(FieldIdentifier identifier, DeclaredType type)
: base(identifier)
{
this.Type = type;
}
