private void AppendInitialiseAttributes(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { foreach (var property in ObjectRecordService.GetFields(recordType)) { var propertyInfo = ObjectRecordService.GetPropertyInfo(property, recordType); var initialiseForAttributes = propertyInfo .GetCustomAttributes <InitialiseFor>() .Where(a => a.PropertyDependency == fieldName); if (initialiseForAttributes.Any()) { onChanges.Add((re) => { foreach (var initialiseForAttribute in initialiseForAttributes) { var dependencyViewModel = re.GetFieldViewModel(fieldName); var dependantViewModel = re.GetFieldViewModel(propertyInfo.Name); if (dependencyViewModel.ValueObject != null && dependencyViewModel.ValueObject.Equals(initialiseForAttribute.ForValue) && (initialiseForAttribute.AlwaysSetIfNotEmpty || dependantViewModel.ValueObject.IsEmpty())) { dependantViewModel.ValueObject = initialiseForAttribute.InitialValue; } } }); } } }
public ObjectFieldViewModel(string fieldName, string fieldLabel, RecordEntryViewModelBase recordForm, bool usePicklist) : base(fieldName, fieldLabel, recordForm, usePicklist) { //okay i need to identify that this is getting the lookups from the settings SettingsAttribute = GetSettingLookupAttribute(); if (SettingsAttribute == null) { //throw new NotImplementedException( // string.Format( // "The {0} Type Has Only Been Implemented For Object Properties With {1} Attribute. You Will Need To Review Instantiating a Different Type Of View Model For The {2} Type Of You Property {3} Or Extending It For Your Needs", // typeof(ObjectFieldViewModel).Name, typeof(SettingsLookup).Name, RecordTypeToLookup, FieldName)); } else { var settingsObject = GetSettingsObject(); XrmButton = new XrmButtonViewModel("Search", Search, ApplicationController); if (settingsObject != null) { _lookupService = new ObjectRecordService(settingsObject, ApplicationController, GetObjectRecordService().ObjectTypeMaps); if (!UsePicklist) { LoadLookupGrid(); } } SetNewAction(); } }
private void AppendDisplayNameAttributes(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { foreach (var property in ObjectRecordService.GetFields(recordType)) { var propertyInfo = ObjectRecordService.GetPropertyInfo(property, recordType); var attributes = propertyInfo .GetCustomAttributes <DisplayNameForPropertyValueAttribute>() .Where(a => a.Property == fieldName); if (attributes.Any()) { onChanges.Add((re) => { foreach (var attribute in attributes) { var dependencyViewModel = re.GetFieldViewModel(fieldName); var dependantViewModel = re.GetFieldViewModel(propertyInfo.Name); if (dependencyViewModel.ValueObject != null && dependencyViewModel.ValueObject.Equals(attribute.Value)) { dependantViewModel.Label = attribute.Label; } } }); } } }
private void AppendUniqueOnAttributes(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { var attributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType).GetCustomAttribute <UniqueOn>(); if (attributes != null) { onChanges.Add( re => re.StartNewAction(() => { //just need to if this in a grid then set all others off if (re is GridRowViewModel) { var gridRowViewModel = (GridRowViewModel)re; var fieldViewModel = gridRowViewModel.GetFieldViewModel(fieldName) as BooleanFieldViewModel; if (fieldViewModel != null && fieldViewModel.Value) { foreach (var row in gridRowViewModel.GridViewModel.GridRecords.ToArray()) { if (row != gridRowViewModel) { ((BooleanFieldViewModel)row.GetFieldViewModel(fieldName)).Value = false; } } } } })); } }
public static ObjectRecordService GetTheService() { if (_theService == null) { _theService = new ObjectRecordService(GetTheObject(), GetTheApplicationController()); } return(_theService); }
public static FormController CreateForObject(object objectToEnter, IApplicationController applicationController, IRecordService lookupService, IDictionary <string, IEnumerable <string> > optionSetLimitedvalues = null) { var recordService = new ObjectRecordService(objectToEnter, lookupService, optionSetLimitedvalues, applicationController); var formService = new ObjectFormService(objectToEnter, recordService); var formController = new FormController(recordService, formService, applicationController); return(formController); }
protected override void LoadDialogExtention() { var recordService = new ObjectRecordService(ObjectToEnter, LookupService, OptionsetLimitedValues, ApplicationController, ObjectTypeMaps); var formService = new ObjectFormService(ObjectToEnter, recordService, ObjectTypeMaps); ViewModel = new ObjectEntryViewModel(StartNextAction, OnCancel, ObjectToEnter, new FormController(recordService, formService, ApplicationController), OnlyValidate); Controller.LoadToUi(ViewModel); }
private void DownloadTemplates(RecordEntryFormViewModel viewModel) { //okay so something to generate one or more csv files with column headings //think will just create a child form entry, generate on save then return to the dialog form try { if (viewModel is ObjectEntryViewModel) { var oevm = viewModel as ObjectEntryViewModel; var templatesRequest = new GenerateTemplatesRequest(); //this is the save function after entering the csvs to generate Action createTemplatesAndReturn = () => { var serviceConnection = viewModel.RecordService.LookupService; //loop through each csv entered and create foreach (var config in templatesRequest.CsvsToGenerate) { var recordType = config.RecordType.Key; var fieldsInEntity = serviceConnection.GetFields(recordType).ToArray(); var fieldsToInclude = config.AllFields ? fieldsInEntity .Where(f => { var mt = serviceConnection.GetFieldMetadata(f, recordType); return(mt.Createable || mt.Writeable); }).ToArray() : config.FieldsToInclude.Select(f => f.RecordField.Key).Intersect(fieldsInEntity).ToArray(); var columnHeadings = templatesRequest.UseSchemaNames ? fieldsToInclude : fieldsToInclude.Select(f => serviceConnection.GetFieldLabel(f, recordType)).ToArray(); var csvText = string.Join(",", columnHeadings.OrderBy(s => s)); var fileNameNoExt = templatesRequest.UseSchemaNames ? recordType : serviceConnection.GetCollectionName(recordType); FileUtility.WriteToFile(templatesRequest.FolderToSaveInto.FolderPath, fileNameNoExt + ".csv", csvText); } viewModel.ApplicationController.StartProcess("explorer", templatesRequest.FolderToSaveInto.FolderPath); //reload the form and notify viewModel.ClearChildForms(); viewModel.LoadCustomFunctions(); }; //load the entry form var os = new ObjectRecordService(templatesRequest, viewModel.RecordService.LookupService, null, viewModel.ApplicationController, null); var ofs = new ObjectFormService(templatesRequest, os, null); var fc = new FormController(os, ofs, viewModel.ApplicationController); var vm = new ObjectEntryViewModel(createTemplatesAndReturn, () => viewModel.ClearChildForms(), templatesRequest, fc); viewModel.LoadChildForm(vm); } } catch (Exception ex) { ApplicationController.ThrowException(ex); } }
public override Action GetBulkAddFunctionFor(string referenceName, RecordEntryViewModelBase recordForm) { var functions = new Dictionary <string, Action>(); var enumeratedType = ObjectRecordService.GetPropertyType(referenceName, recordForm.GetRecordType()).GenericTypeArguments[0]; var customFunction = enumeratedType.GetCustomAttribute <BulkAddFunction>(); return(customFunction != null ? customFunction.GetCustomFunction(recordForm, referenceName) : null); }
public ObjectEntryViewModel LoadToObjectEntryViewModel(object objectToEnter) { var applicationController = new FakeApplicationController(); var recordService = new ObjectRecordService(objectToEnter, applicationController); var formService = new ObjectFormService(objectToEnter, recordService); var viewModel = new ObjectEntryViewModel(EmptyMethod, EmptyMethod, objectToEnter, new FormController(recordService, formService, applicationController)); viewModel.LoadFormSections(); Assert.IsNotNull(viewModel.FormSectionsAsync); return(viewModel); }
public override IEnumerable <ValidationRuleBase> GetSectionValidationRules(string sectionIdentifier) { if (ObjectType.GetProperty(sectionIdentifier) != null) { return (ObjectRecordService.GetValidatorAttributes(sectionIdentifier, ObjectType.AssemblyQualifiedName) .Select(va => new PropertyAttributeValidationRule(va))); } else { return(new ValidationRuleBase[0]); } }
internal override IEnumerable <CustomFormFunction> GetCustomFunctions(string recordType, RecordEntryFormViewModel recordForm) { var type = ObjectRecordService.GetClassType(recordType); var customGridFunctions = new List <CustomFormFunction>(); var typesToResolve = GetTypesToResolve(type); foreach (var typeToResolve in typesToResolve) { var injectedFunctions = recordForm.ApplicationController.ResolveInstance(typeof(CustomFormFunctions), typeToResolve.AssemblyQualifiedName) as CustomFormFunctions; customGridFunctions.AddRange(injectedFunctions.CustomFunctions); } return(customGridFunctions); }
protected override void LoadDialogExtention() { LoadingViewModel.LoadingMessage = "Loading Entry Form"; var recordService = new ObjectRecordService(ObjectToEnter, LookupService, OptionsetLimitedValues, ApplicationController, ObjectTypeMaps); var formService = new ObjectFormService(ObjectToEnter, recordService, ObjectTypeMaps); ViewModel = new ObjectEntryViewModel(StartNextAction, OnCancel, ObjectToEnter, new FormController(recordService, formService, ApplicationController), OnlyValidate, saveButtonLabel: SaveButtonLabel, cancelButtonLabel: CancelButtonLabel); if (InitialMessage != null) { ViewModel.ValidationPrompt = InitialMessage; } Controller.LoadToUi(ViewModel); }
public override IEnumerable <ValidationRuleBase> GetValidationRules(string fieldName, string recordType) { var validators = new List <ValidationRuleBase>(); var type = ObjectRecordService.GetPropertyType(fieldName, ObjectType.AssemblyQualifiedName); var isValidatable = type.IsTypeOf(typeof(IValidatableObject)); if (isValidatable) { validators.Add(new IValidatableObjectValidationRule()); } validators.AddRange(ObjectRecordService.GetValidatorAttributes(fieldName, ObjectType.AssemblyQualifiedName) .Select(va => new PropertyAttributeValidationRule(va))); return(validators); }
public override IEnumerable <Condition> GetLookupConditions(string fieldName, string recordType, string reference, IRecord record) { var propertyInfo = GetPropertyInfo(fieldName, recordType); var attr = propertyInfo.GetCustomAttributes <LookupCondition>(); var conditions = attr == null ? new Condition[0].ToList() : attr.Select(a => a.ToCondition()).ToList(); var otherCondition = ObjectRecordService.GetLookupConditionFors(fieldName, recordType, reference, record); if (otherCondition != null) { conditions.Add(otherCondition); } return(conditions); }
private void SetNewAction() { if (SettingsAttribute.AllowAddNew) { NewAction = () => { var settingsObject = GetSettingsObject(); var propertyInfo = settingsObject.GetType().GetProperty(SettingsAttribute.PropertyName); var enumerateType = propertyInfo.PropertyType.GenericTypeArguments[0]; var newSettingObject = enumerateType.CreateFromParameterlessConstructor(); var objectRecordService = new ObjectRecordService(newSettingObject, ApplicationController, null); var formService = new ObjectFormService(newSettingObject, objectRecordService); var formController = new FormController(objectRecordService, formService, ApplicationController); Action onSave = () => { //add the new item to the permanent settings var settingsManager = ApplicationController.ResolveType <ISettingsManager>(); settingsObject = GetSettingsObject(); var settingsService = new ObjectRecordService(settingsObject, ApplicationController); var currentSettings = settingsService.RetrieveAll(enumerateType.AssemblyQualifiedName, null) .Select(r => ((ObjectRecord)r).Instance) .ToList(); currentSettings.Add(newSettingObject); settingsObject.SetPropertyValue(SettingsAttribute.PropertyName, enumerateType.ToNewTypedEnumerable(currentSettings)); settingsManager.SaveSettingsObject(settingsObject); ValueObject = newSettingObject; if (UsePicklist) { //reload the picklist ValueObject = newSettingObject; LoadPicklistItems(); } else { SetEnteredTestWithoutClearingValue(ValueObject.ToString()); } RecordEntryViewModel.ClearChildForm(); }; var newSettingForm = new ObjectEntryViewModel(onSave, RecordEntryViewModel.ClearChildForm, newSettingObject, formController); RecordEntryViewModel.LoadChildForm(newSettingForm); }; } }
private void AppendReadOnlyWhenSetAttributes(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { var attributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType).GetCustomAttribute <ReadOnlyWhenSet>(); if (attributes != null) { onChanges.Add( re => re.StartNewAction(() => { //just need to if this in a grid then set all others off var fieldViewModel = re.GetFieldViewModel(fieldName); if (fieldViewModel != null) { fieldViewModel.IsEditable = fieldViewModel.ValueObject == null; } })); } }
private void AppendSubGridButtons(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > methods) { var fieldMetadata = ObjectRecordService.GetFieldMetadata(fieldName, recordType); if (fieldMetadata.FieldType == RecordFieldType.Enumerable) { methods.Add( re => re.StartNewAction(() => { if (re is RecordEntryFormViewModel) { var refvm = re as RecordEntryFormViewModel; var customFunctions = GetCustomFunctionsFor(fieldName, refvm).ToList(); var fieldVm = refvm.GetEnumerableFieldViewModel(fieldName); fieldVm.DynamicGridViewModel.AddGridButtons(customFunctions); } })); } }
public override RecordEntryFormViewModel GetEditRowViewModel(string subGridName, RecordEntryViewModelBase parentForm, Action <IRecord> onSave, Action onCancel, GridRowViewModel gridRow) { var record = gridRow.GetRecord(); if (!(record is ObjectRecord)) { throw new NotSupportedException(string.Format("Error Expected Object Of Type {0}", typeof(ObjectRecord).Name)); } var newRecord = (ObjectRecord)record; //need to load the existing row to this //lets start a dialog to add it on complete var mapper = new ClassSelfMapper(); var newObject = mapper.Map(newRecord.Instance); var recordService = new ObjectRecordService(newObject, ObjectRecordService.LookupService, ObjectRecordService.OptionSetLimitedValues, ObjectRecordService, subGridName, parentForm.ApplicationController); var viewModel = new ObjectEntryViewModel( () => onSave(new ObjectRecord(newObject)), onCancel, newObject, new FormController(recordService, new ObjectFormService(newObject, recordService), parentForm.FormController.ApplicationController), parentForm, subGridName, parentForm.OnlyValidate); return(viewModel); }
private void AppendCascadeOnChanges(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { var lookupForAttributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType) .GetCustomAttributes(typeof(CascadeOnChange), true).Cast <CascadeOnChange>(); foreach (var attribute in lookupForAttributes) { onChanges.Add( re => { var changedViewModel = re.GetFieldViewModel(fieldName); if (changedViewModel.ValueObject != null) { var matchingFields = re.FieldViewModels.Where(f => f.FieldName == attribute.TargetProperty); if (matchingFields.Any()) { matchingFields.First().ValueObject = changedViewModel.ValueObject; } } }); } }
private void AppendConnectionForChanges(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges, bool isOnLoad) { var lookupForAttributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType) .GetCustomAttributes(typeof(ConnectionFor), true).Cast <ConnectionFor>(); foreach (var attribute in lookupForAttributes) { onChanges.Add( re => { var changedViewModel = re.GetFieldViewModel(fieldName); if (changedViewModel.ValueObject != null) { var matchingFields = re.FieldViewModels.Where(f => f.FieldName == attribute.Property); if (matchingFields.Any()) { var fieldViewModel = matchingFields.First(); if (!isOnLoad && fieldViewModel is LookupFieldViewModel) { var typedViewModel = (LookupFieldViewModel)fieldViewModel; typedViewModel.ConnectionForChanged(); } if (fieldViewModel is RecordTypeFieldViewModel) { var typedViewModel = (RecordTypeFieldViewModel)fieldViewModel; typedViewModel.ItemsSource = ObjectRecordService .GetPicklistKeyValues(fieldViewModel.FieldName, fieldViewModel.GetRecordType()) .Select(p => new RecordType(p.Key, p.Value)) .Where(rt => !rt.Value.IsNullOrWhiteSpace()) .OrderBy(rt => rt.Value) .ToArray(); } } } }); } }
private void AppendLookupFieldCascadeChanges(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges) { var lookupForAttributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType) .GetCustomAttributes(typeof(LookupFieldCascade), true).Cast <LookupFieldCascade>(); foreach (var attribute in lookupForAttributes) { onChanges.Add( re => { var changedViewModel = re.GetFieldViewModel(fieldName); if (changedViewModel.ValueObject != null) { var changedViewModelLookup = ((LookupFieldViewModel)changedViewModel).Value; var matchingFields = re.FieldViewModels.Where(f => f.FieldName == attribute.TargetProperty); var lookupService = ObjectRecordService.GetLookupService(changedViewModel.FieldName, re.GetRecordType(), re.ParentFormReference, re.GetRecord()); if (lookupService != null) { var lookupRecord = lookupService.Get(changedViewModelLookup.RecordType, changedViewModelLookup.Id); if (lookupRecord == null) { changedViewModel.ValueObject = null; re.ApplicationController.UserMessage(string.Format("The {0} Was Not Found And The Value Has Been Cleared", changedViewModel.Label)); } else { var sourceFieldValue = lookupRecord.GetField(attribute.SourceRecordField); if (matchingFields.Any()) { matchingFields.First().ValueObject = sourceFieldValue; } } } } }); } }
internal void SetItemsSource(IEnumerable <T> items) { ItemsSource = items == null ? new SelectablePicklistOption[0] : items.Select(i => new SelectablePicklistOption(i, RefreshSelectedItemsIntoValue, Value != null && Value.Any(v => v == i))).ToArray(); var optionsObject = new SelectablePicklistOptions() { Options = ItemsSource }; var recordService = new ObjectRecordService(optionsObject, ApplicationController); Func <IEnumerable <IRecord> > getRecordsFunc = () => recordService.RetreiveAll(new QueryDefinition(typeof(SelectablePicklistOption).AssemblyQualifiedName)); DynamicGridViewModel = new DynamicGridViewModel(ApplicationController) { ViewType = ViewType.LookupView, FormController = new FormController(recordService, null, ApplicationController), RecordType = typeof(SelectablePicklistOption).AssemblyQualifiedName, RecordService = recordService, GetGridRecords = (b) => new GetGridRecordsResponse(getRecordsFunc()), IsReadOnly = true }; Action onClick = () => { var selectedItem = DynamicGridViewModel.SelectedRow; if (selectedItem != null) { var isSelectedField = selectedItem.GetBooleanFieldFieldViewModel(nameof(SelectablePicklistOption.Select)); isSelectedField.Value = !isSelectedField.Value; DynamicGridViewModel.SelectedRow = null; } }; DynamicGridViewModel.OnClick = onClick; DoOnAsynchThread(() => { DynamicGridViewModel.GridRecords = GridRowViewModel.LoadRows(getRecordsFunc(), DynamicGridViewModel); OnPropertyChanged(nameof(DynamicGridViewModel)); OnPropertyChanged(nameof(StringDisplay)); }); }
internal override IEnumerable <CustomGridFunction> GetCustomFunctionsFor(string referenceName, RecordEntryFormViewModel recordForm) { var functions = new Dictionary <string, Action>(); var recordType = recordForm.GetEnumerableFieldViewModel(referenceName).RecordType; if (recordType == null) { return(new CustomGridFunction[0]); } var enumeratedType = ObjectRecordService.GetClassType(recordType); var customFunctions = enumeratedType.GetCustomAttributes <CustomFunction>(); if (customFunctions != null) { foreach (var item in customFunctions) { functions.Add(item.GetFunctionLabel(), item.GetCustomFunction(recordForm, referenceName)); } } var allowDownloadAttribute = ObjectRecordService.GetPropertyInfo(referenceName, recordForm.RecordType).GetCustomAttribute <AllowDownload>(); if (allowDownloadAttribute != null) { functions.Add("Download CSV", () => { recordForm.GetEnumerableFieldViewModel(referenceName).DynamicGridViewModel.DownloadCsv(); }); } var customGridFunctions = functions.Select(kv => new CustomGridFunction(kv.Key, kv.Key, kv.Value)).ToList(); var typesToResolve = GetTypesToResolve(enumeratedType); foreach (var typeToResolve in typesToResolve) { var injectedFunctions = recordForm.ApplicationController.ResolveInstance(typeof(CustomGridFunctions), typeToResolve.AssemblyQualifiedName) as CustomGridFunctions; customGridFunctions.AddRange(injectedFunctions.CustomFunctions); } return(customGridFunctions); }
internal override RecordEntryFormViewModel GetLoadRowViewModel(string subGridName, RecordEntryViewModelBase parentForm, Action <IRecord> onSave, Action onCancel) { var propertyInfo = ObjectToEnter.GetType().GetProperty(subGridName); if (propertyInfo.GetCustomAttribute <FormEntry>() != null) { //lets start a dialog to add it on complete var fieldMetadata = (EnumerableFieldMetadata)ObjectRecordService.GetFieldMetadata(propertyInfo.Name, ObjectToEnter.GetType().AssemblyQualifiedName); var newRecord = (ObjectRecord)ObjectRecordService.NewRecord(fieldMetadata.EnumeratedTypeQualifiedName); var newObject = newRecord.Instance; var recordService = new ObjectRecordService(newObject, ObjectRecordService.LookupService, ObjectRecordService.OptionSetLimitedValues, ObjectRecordService, subGridName, parentForm.ApplicationController); var viewModel = new ObjectEntryViewModel( () => onSave(new ObjectRecord(newObject)), onCancel, newObject, new FormController(recordService, new ObjectFormService(newObject, recordService), parentForm.FormController.ApplicationController), parentForm, subGridName, parentForm.OnlyValidate); return(viewModel); //ideally could hide the parent dialog temporarily and load this one } //if the object specifies use a form then use the form/dialog else { return(null); } }
private void AppendFieldForChanges(string fieldName, string recordType, List <Action <RecordEntryViewModelBase> > onChanges, bool clearValue = false) { var lookupForAttributes = ObjectRecordService.GetPropertyInfo(fieldName, recordType) .GetCustomAttributes(typeof(RecordFieldFor), true).Cast <RecordFieldFor>(); foreach (var attribute in lookupForAttributes) { onChanges.Add( re => re.StartNewAction(() => { var recordFieldViewModel = re.GetRecordFieldFieldViewModel(fieldName); if (recordFieldViewModel.Value != null) { var matchingFields = re.FieldViewModels.Where(f => f.FieldName == attribute.PropertyPaths.First()); foreach (var fieldViewModel in matchingFields.ToArray()) { var selectedFieldName = recordFieldViewModel.Value.Key; var selectedFieldRecordType = GetRecordTypeFor(recordFieldViewModel.FieldName, re); var lookupService = re.RecordService.GetLookupService(recordFieldViewModel.FieldName, recordFieldViewModel.GetRecordType(), null, recordFieldViewModel.RecordEntryViewModel.GetRecord()); if (lookupService != null) { //get the source field type var fieldType = lookupService.GetFieldType(selectedFieldName, selectedFieldRecordType); //get the section the target field is in and its field metadata var metadata = re.FormService.GetFormMetadata(re.GetRecordType(), ObjectRecordService); FormFieldMetadata fieldMetadata = null; string sectionName = null; foreach (var sectionMetadata in metadata.FormSections.Cast <FormFieldSection>()) { foreach (var field in sectionMetadata.FormFields) { if (field.FieldName == fieldViewModel.FieldName) { sectionName = sectionMetadata.SectionLabel; fieldMetadata = field; } } } if (!string.IsNullOrWhiteSpace(sectionName)) { var targetPropInfo = ObjectRecordService.GetPropertyType(attribute.PropertyPaths.First(), recordType); if (targetPropInfo.IsEnum) { //if target is an enum then filter the items source for the field type var picklistFieldViewModel = fieldViewModel as PicklistFieldViewModel; var picklistOptions = ObjectRecordService.GetPicklistKeyValues(picklistFieldViewModel.FieldName, picklistFieldViewModel.GetRecordType(), fieldType.ToString(), picklistFieldViewModel.RecordEntryViewModel.GetRecord()); if (clearValue) { picklistFieldViewModel.Value = null; } picklistFieldViewModel.ItemsSource = picklistOptions; } else { //otherwise is a field input dynamic for the field's tpye //now we need to create the view model for the target field as the correct type //okay now we need to replace the old field view model for this field var explicitTargetType = fieldType == RecordFieldType.Lookup || fieldType == RecordFieldType.Customer || fieldType == RecordFieldType.Owner ? lookupService.GetLookupTargetType(selectedFieldName, selectedFieldRecordType) : null; var explicitPicklistOptions = fieldType == RecordFieldType.Picklist || fieldType == RecordFieldType.Status || fieldType == RecordFieldType.State || fieldType == RecordFieldType.Integer ? lookupService.GetPicklistKeyValues(selectedFieldName, selectedFieldRecordType) : null; if (clearValue) { fieldViewModel.ValueObject = null; } var newFieldViewModel = fieldMetadata.CreateFieldViewModel(re.GetRecordType(), re.RecordService, re, re.ApplicationController, explicitFieldType: fieldType, explicitLookupTargetType: explicitTargetType, explicitPicklistOptions: explicitPicklistOptions); var section = re.FieldSections.First(s => s.SectionLabel == sectionName); var index = section.Fields.Count; for (var i = 0; i < section.Fields.Count; i++) { if (section.Fields[i].FieldName == fieldViewModel.FieldName) { index = i; break; } } re.DoOnMainThread(() => { if (section.Fields.Count > index) { section.Fields.RemoveAt(index); } if (clearValue) { fieldViewModel.ValueObject = null; } section.Fields.Insert(index, newFieldViewModel); re.RefreshVisibility(); }); } } } } } })); } }
private string GetRecordTypeFor(string field, RecordEntryViewModelBase viewModel) { var split = field?.Split('.') ?? new string[0]; if (!split.Any()) { return(null); } var propertyInfo = GetPropertyInfo(split.First(), viewModel.GetRecord().Type); if (propertyInfo != null) { if (propertyInfo.GetType().Name == "IEnumerable`1" && split.Count() > 1) { var enumeratedType = propertyInfo.GetType().GenericTypeArguments[0]; propertyInfo = enumeratedType.GetProperty(split.ElementAt(1)) ?? propertyInfo; } var attribute = propertyInfo.GetCustomAttribute <ReferencedType>(); if (attribute != null) { return(attribute.Type); } } foreach (var parentField in ObjectRecordService.GetPropertyInfos(viewModel.GetRecordType())) { var lookupForAttributes = parentField.GetCustomAttributes(typeof(RecordTypeFor), true).Cast <RecordTypeFor>(); foreach (var lookupForAttribute in lookupForAttributes) { if (lookupForAttribute.LookupProperty == field) { //can't use the field view model as called on load and may trigger infinite loop loading field list var record = viewModel.GetRecord(); if (record is ObjectRecord) { var objectrecord = (ObjectRecord)record; var propertyValue = objectrecord.Instance.GetPropertyValue(parentField.Name); if (propertyValue is RecordType) { return(((RecordType)propertyValue).Key); } } } } } var parentForm = viewModel.ParentForm; if (parentForm is ObjectEntryViewModel) { foreach (var parentField in ((ObjectEntryViewModel)parentForm).GetObject().GetType().GetProperties()) { var lookupForAttributes = parentField.GetCustomAttributes(typeof(RecordTypeFor), true).Cast <RecordTypeFor>(); foreach (var lookupForAttribute in lookupForAttributes) { if (lookupForAttribute.PropertyPaths.Count() == 2 && lookupForAttribute.PropertyPaths.First() == viewModel.ParentFormReference && lookupForAttribute.PropertyPaths.Last() == field) { var parentsFieldViewmOdel = parentForm.GetRecordTypeFieldViewModel(parentField.Name); if (parentsFieldViewmOdel.Value != null) { return(parentsFieldViewmOdel.Value.Key); } } } } } return(null); }
public StringAutocompleteViewModel(StringFieldViewModel stringField, AutocompleteFunction autocompleteFunction) : base(stringField.ApplicationController) { SearchText = stringField.Value; StringField = stringField; AutocompleteFunction = autocompleteFunction; var typeAheadOptions = new TypeAheadOptions(); var typeAheadRecordService = new ObjectRecordService(typeAheadOptions, ApplicationController); var formController = FormController.CreateForObject(typeAheadOptions, ApplicationController, null); IEnumerable <object> autoCompleteStrings = null; if (AutocompleteFunction.CacheAsStaticList) { try { autoCompleteStrings = autocompleteFunction.GetAutocompleteStrings(StringField.RecordEntryViewModel); } catch (Exception ex) { StringField.AddError($"Error Loading Autocomplete {ex.Message}\n{ex.DisplayString()}"); } } Func <bool, GetGridRecordsResponse> getGridRecords = (ignorePages) => { try { LoadOptionsError = null; autoCompleteStrings = autoCompleteStrings != null && AutocompleteFunction.CacheAsStaticList ? autoCompleteStrings : autocompleteFunction .GetAutocompleteStrings(StringField.RecordEntryViewModel); if (autoCompleteStrings == null) { return(new GetGridRecordsResponse(new IRecord[0])); } var searchToLower = SearchText?.ToLower(); typeAheadOptions.Options = autoCompleteStrings .Where(ta => searchToLower == null || AutocompleteFunction.SearchFields.Any(sf => ta.GetPropertyValue(sf)?.ToString().ToLower().StartsWith(searchToLower) ?? false)) .OrderBy(ta => (string)ta.GetPropertyValue(AutocompleteFunction.SortField)) .ThenBy(ta => (string)ta.GetPropertyValue(AutocompleteFunction.ValueField)); var records = typeAheadOptions .Options .Select(o => new ObjectRecord(o)) .Take(MaxRecordsForLookup) .ToArray(); if (stringField.DisplayAutocomplete && (!records.Any() || (records.Count() == 1 && records.First().GetStringField(AutocompleteFunction.ValueField)?.ToLower() == searchToLower))) { stringField.DisplayAutocomplete = false; } else { stringField.DisplayAutocomplete = true; } return(new GetGridRecordsResponse(records)); } catch (Exception ex) { LoadOptionsError = $"Autocomplete could not be loaded\n\n{ex.Message}{(ex.InnerException == null ? null : ("\n\n" + ex.InnerException.Message))}\n\n{ex.StackTrace}"; return(new GetGridRecordsResponse(new IRecord[0])); } }; DynamicGridViewModel = new DynamicGridViewModel(ApplicationController) { FormController = formController, GetGridRecords = getGridRecords, OnDoubleClick = OnDoubleClick, ViewType = ViewType.LookupView, RecordService = typeAheadRecordService, RecordType = AutocompleteFunction.RecordType, IsReadOnly = true, DisplayHeaders = false, NoMargins = true, FieldMetadata = AutocompleteFunction.GridFields }; }
private PropertyInfo GetPropertyInfo(string field, string type) { var propertyInfo = ObjectRecordService.GetPropertyInfo(field, type); return(propertyInfo); }
public void WriteObject(object objectToWrite) { var objectRecord = new ObjectRecord(objectToWrite); var recordService = new ObjectRecordService(objectToWrite, null); var formService = new ObjectFormService(objectToWrite, recordService); var formMetadata = formService.GetFormMetadata(objectToWrite.GetType().AssemblyQualifiedName); foreach (var section in formMetadata.FormSections.OrderBy(s => s.Order)) { if (section is FormFieldSection fieldSection) { if (fieldSection.FormFields.Any(f => objectToWrite.IsInContext(f.FieldName))) { _content.AppendLine("<p>"); if (fieldSection.DisplayLabel) { AppendSectionHeading(fieldSection.SectionLabel); } foreach (var field in fieldSection.FormFields.OrderBy(f => f.Order)) { if (objectToWrite.IsInContext(field.FieldName)) { if (field.DisplayLabel) { AppendFieldHeading(recordService.GetFieldLabel(field.FieldName, objectRecord.Type)); } if (recordService.GetFieldType(field.FieldName, objectRecord.Type) == RecordFieldType.Enumerable) { //okay need to generate a table var enumerableMetadata = recordService.GetFieldMetadata(field.FieldName, objectRecord.Type) as EnumerableFieldMetadata; var gridFieldMetadata = recordService.GetGridFields(enumerableMetadata.EnumeratedTypeQualifiedName, ViewType.AssociatedView); var table = new StringBuilder(); table.AppendLine("<table>"); table.AppendLine("<thead><tr>"); var fieldJustifies = new Dictionary <string, string>(); foreach (var gridField in gridFieldMetadata) { var justify = recordService.GetFieldType(gridField.FieldName, enumerableMetadata.EnumeratedTypeQualifiedName).GetHorizontalJustify(true); var htmlJustify = justify == HorizontalJustify.Left ? "left" : justify == HorizontalJustify.Middle ? "center" : "right"; fieldJustifies.Add(gridField.FieldName, htmlJustify); } foreach (var gridField in gridFieldMetadata) { table.AppendLine($"<th width={gridField.WidthPart} {thStyle.Replace("left", fieldJustifies[gridField.FieldName])}>{recordService.GetFieldLabel(gridField.FieldName, enumerableMetadata.EnumeratedTypeQualifiedName)}</th>"); } table.AppendLine("</tr></thead>"); var linkedObjects = recordService .GetLinkedRecords(enumerableMetadata.EnumeratedTypeQualifiedName, objectRecord.Type, field.FieldName, objectRecord.Id) .Cast <ObjectRecord>() .ToArray(); var objectsForTable = linkedObjects .Take(MaximumNumberOfEntitiesToList) .ToArray(); foreach (var gridRecord in objectsForTable.Take(MaximumNumberOfEntitiesToList)) { table.AppendLine("<tr>"); foreach (var gridField in gridFieldMetadata .Where(gf => objectsForTable.Any(o => o.Instance.IsInContext(gf.FieldName)))) { table.AppendLine(string.Format("<td {0}>", tdStyle.Replace("left", fieldJustifies[gridField.FieldName]))); table.Append(recordService.GetFieldAsDisplayString(gridRecord, gridField.FieldName)); table.AppendLine("</td>"); } table.AppendLine("</tr>"); } table.AppendLine("</table>"); _content.AppendLine(table.ToString()); if (linkedObjects.Count() > MaximumNumberOfEntitiesToList) { AppendParagraph(string.Format("Note this list is incomplete as the maximum of {0} items has been listed", MaximumNumberOfEntitiesToList)); } } else { AppendFieldValue(recordService.GetFieldAsDisplayString(objectRecord, field.FieldName)); } } } _content.AppendLine("</p>"); } } } }