/// <summary>
        /// Fieldses for edit field context.
        /// </summary>
        /// <param name="editFieldContext">
        /// The edit field context.
        /// </param>
        /// <returns>
        /// The <see cref="List"/>.
        /// </returns>
        public virtual List <UPMField> FieldsForEditFieldContext(UPEditFieldContext editFieldContext)
        {
            if (editFieldContext == null)
            {
                return(null);
            }

            if (editFieldContext.ReadOnly)
            {
                var field = editFieldContext.Field;
                return(field != null ? new List <UPMField> {
                    editFieldContext.Field
                } : null);
            }

            var fieldArray = new List <UPMField>();
            var editFields = editFieldContext.EditFields;

            if (editFields != null)
            {
                foreach (var editField in editFields)
                {
                    editField.EditFieldsContext = this.EditPageContext;
                    fieldArray.Add(editField);
                }
            }

            return(fieldArray);
        }
 private void FillUploadRequestsForRecord(UPCRMRecord record)
 {
     this.uploadDocumentRequests = new List <UPOfflineUploadDocumentRequest>();
     foreach (UPPageModelController modelController in this.PageModelControllers)
     {
         if (modelController is EditPageModelController)
         {
             ObjectivesEditPageModelController editModelController = (ObjectivesEditPageModelController)modelController;
             UPMObjectivesPage editPage = (UPMObjectivesPage)editModelController.Page;
             foreach (UPMGroup editGroup in editPage.Groups)
             {
                 foreach (UPMObjective objective in editGroup.Children)
                 {
                     foreach (UPMEditField editField in objective.Fields)
                     {
                         if (editField is UPMImageEditField && editField.Changed)
                         {
                             UPMImageEditField  imageEditField = (UPMImageEditField)editField;
                             UPEditFieldContext fieldContext   = editModelController.FieldContextForEditField(imageEditField);
                             //this.uploadDocumentRequest = new UPOfflineUploadDocumentRequest(UIImageJPEGRepresentation(imageEditField.Image, 1.0), -1, "photo.jpg", "image/jpeg", record.RecordIdentification, fieldContext.FieldId, "true");         // CRM-5007
                             this.uploadDocumentRequests.Add(this.uploadDocumentRequest);
                         }
                     }
                 }
             }
         }
     }
 }
예제 #3
0
        private void HandleDependentFieldsSectionCounterItemCounter(Dictionary <string, UPEditFieldContext> editFields, int sectionCounter, int itemCounter)
        {
            List <UPEditFieldContext> parentFieldContextArray = new List <UPEditFieldContext>();

            foreach (UPEditFieldContext fieldContext in editFields.Values)
            {
                UPCRMField parentField = fieldContext.ParentField;
                if (parentField != null)
                {
                    UPEditFieldContext parentFieldContext = this.editPageContext.EditFields.ValueOrDefault(this.FieldIdentificationSectionCounterItemCounter(parentField, sectionCounter, itemCounter));
                    if (parentFieldContext != null)
                    {
                        parentFieldContext.AddDependentFieldContext(fieldContext);
                        if (parentFieldContextArray.Contains(parentFieldContext) == false)
                        {
                            parentFieldContextArray.Add(parentFieldContext);
                        }
                    }
                }
            }

            foreach (UPEditFieldContext parentFieldContext in parentFieldContextArray)
            {
                parentFieldContext.NotifyDependentFields();
            }
        }
        /// <summary>
        /// Fieldses for edit field context.
        /// </summary>
        /// <param name="editFieldContext">The edit field context.</param>
        /// <returns>
        /// The <see cref="List" />.
        /// </returns>
        public override List <UPMField> FieldsForEditFieldContext(UPEditFieldContext editFieldContext)
        {
            List <UPMField> editFieldArray = base.FieldsForEditFieldContext(editFieldContext);

            if (editFieldArray != null)
            {
                foreach (UPMEditField editField in editFieldArray)
                {
                    editField.EditFieldDelegate = this;
                    editField.ContinuousUpdate  = true;
                    if (!string.IsNullOrEmpty(editFieldContext.FieldFunction))
                    {
                        this.editFieldDictionary[editFieldContext.FieldFunction] = editFieldContext;
                        if (editField.RequiredField)
                        {
                            if (!editFieldContext.FieldConfig.IsEmptyValue(string.Empty))
                            {
                                this.mustFieldDictionary[editFieldContext.FieldFunction] = "0";
                            }
                            else
                            {
                                this.mustFieldDictionary[editFieldContext.FieldFunction] = string.Empty;
                            }
                        }
                    }

                    if (editField is UPMCatalogEditField)
                    {
                        ((UPMCatalogEditField)editField).CatalogElementViewType = CatalogElementViewType.PopOver;
                    }
                }
            }

            return(editFieldArray);
        }
        /// <summary>
        /// Groups from row.
        /// </summary>
        /// <param name="resultRow">The result row.</param>
        /// <returns>
        /// The <see cref="UPMGroup" />.
        /// </returns>
        public override UPMGroup GroupFromRow(UPCRMResultRow resultRow)
        {
            UPMGroup group = base.GroupFromRow(resultRow);

            this.skipTemplateFilter = false;
            if (group != null)
            {
                if (this.emptyMustFieldCount < 0)
                {
                    this.emptyMustFieldCount = 0;
                    List <string> mustFieldFunctionNames = this.mustFieldDictionary.Keys.ToList();
                    foreach (string functionName in mustFieldFunctionNames)
                    {
                        UPEditFieldContext ctx = this.editFieldDictionary[functionName];
                        if (ctx.FieldConfig.IsEmptyValue(ctx.Value))
                        {
                            this.emptyMustFieldCount++;
                            this.mustFieldDictionary[functionName] = string.Empty;
                        }
                        else if (string.IsNullOrEmpty(ctx.Value))
                        {
                            this.mustFieldDictionary[functionName] = "0";
                        }
                        else
                        {
                            this.mustFieldDictionary[functionName] = ctx.Value;
                        }
                    }
                }

                this.Delegate.GroupModelControllerValueChanged(this, this.CurrentData);
            }

            return(group);
        }
예제 #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UPEditConstraintViolation"/> class.
 /// </summary>
 /// <param name="context">
 /// The context.
 /// </param>
 /// <param name="violationType">
 /// Type of the violation.
 /// </param>
 /// <param name="violationKey">
 /// The violation key.
 /// </param>
 public UPEditConstraintViolation(
     UPEditFieldContext context,
     EditConstraintViolationType violationType,
     string violationKey)
 {
     this.EditFieldContext = context;
     this.ViolationType    = violationType;
     this.ViolationKey     = violationKey;
 }
        /// <summary>
        /// Applies the context.
        /// </summary>
        /// <param name="contextDictionary">The context dictionary.</param>
        /// <returns></returns>
        public override UPMGroup ApplyContext(Dictionary <string, object> contextDictionary)
        {
            UPMGroup returnGroup;

            base.ApplyContext(contextDictionary);
            if (!this.skipTemplateFilter)
            {
                string templateFilterName = this.FormItem.ViewReference.ContextValueForKey("Func1");
                Dictionary <string, object> initialValues = null;
                if (!string.IsNullOrEmpty(templateFilterName))
                {
                    UPConfigFilter templateFilter = ConfigurationUnitStore.DefaultStore.FilterByName(templateFilterName);
                    if (templateFilter != null)
                    {
                        Dictionary <string, object> dict = contextDictionary["$_copyFields"] as Dictionary <string, object>;
                        templateFilter = templateFilter.FilterByApplyingValueDictionaryDefaults(dict, true);
                        initialValues  = templateFilter.FieldsWithValues(true, true);
                    }
                }

                this.EditPageContext    = new UPEditPageContext(this.FieldControl.InfoAreaId, true, initialValues, null, null);
                returnGroup             = this.ApplyResultRow(null);
                this.skipTemplateFilter = true;
            }
            else
            {
                returnGroup = this.Group;
            }

            if (this.dependentFieldDictionary != null)
            {
                foreach (string dependentKey in this.dependentFieldDictionary.Keys)
                {
                    if (contextDictionary.Keys.Contains(dependentKey))
                    {
                        string depVal = contextDictionary[dependentKey] as string;
                        if (!string.IsNullOrEmpty(depVal))
                        {
                            UPEditFieldContext editFieldContext =
                                this.editFieldDictionary[this.dependentFieldDictionary[dependentKey]];
                            if (editFieldContext != null)
                            {
                                editFieldContext.Value = depVal;
                                if (editFieldContext.EditField != null)
                                {
                                    this.SimpleChangedValue(editFieldContext.EditField);
                                }
                            }
                        }
                    }
                }
            }

            return(returnGroup);
        }
 private void UpdateChildEditContext(UPChildEditContext childEditContext, Dictionary <string, object> _initialValues)
 {
     foreach (string fieldKey in _initialValues.Keys)
     {
         UPEditFieldContext editFieldContext = childEditContext.EditFieldContext[fieldKey];
         if (editFieldContext != null)
         {
             editFieldContext.SetValue(_initialValues[fieldKey] as string);
             editFieldContext.ChildEditContext = childEditContext;
         }
     }
 }
        private void UserDidChangeCatalogField(UPMCatalogEditField editField)
        {
            UPEditPageContext  fieldEditPageContext = (UPEditPageContext)editField.EditFieldsContext;
            UPEditFieldContext context = fieldEditPageContext.ContextForEditField(editField);

            if (context.HasDependentFields)
            {
                context.NotifyDependentFields();
                this.SimpleChangedValue(editField);
                this.Delegate.ForceRedraw(this);
            }
            else
            {
                this.SimpleChangedValue(editField);
            }
        }
        private bool NeedsSignalValueChange(UPMEditField editField)
        {
            if (editField.RequiredField)
            {
                if (this.currentField != editField)
                {
                    foreach (UPEditFieldContext ctx in this.editFieldDictionary.Values)
                    {
                        if (ctx.EditField == editField)
                        {
                            this.currentContext = ctx;
                            break;
                        }
                    }

                    this.currentField = editField;
                }

                if (this.currentContext != null)
                {
                    string val       = this.currentContext.Value;
                    string storedVal = this.mustFieldDictionary[this.currentContext.FieldFunction];
                    if (!string.IsNullOrEmpty(val) && string.IsNullOrEmpty(storedVal))
                    {
                        this.mustFieldDictionary[this.currentContext.FieldFunction] = val;
                        return(--this.emptyMustFieldCount == 0);
                    }

                    if (string.IsNullOrEmpty(val) && !string.IsNullOrEmpty(storedVal))
                    {
                        this.mustFieldDictionary[this.currentContext.FieldFunction] = string.Empty;
                        return(++this.emptyMustFieldCount == 1);
                    }

                    if (!string.IsNullOrEmpty(val))
                    {
                        this.mustFieldDictionary[this.currentContext.FieldFunction] = val;
                    }

                    return(this.emptyMustFieldCount <= 0 && this.SignalEveryChange);
                }
            }

            return(this.SignalEveryChange);
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="UPInBoxPageModelController"/> class.
        /// </summary>
        /// <param name="viewReference">The view reference.</param>
        public UPInBoxPageModelController(ViewReference viewReference)
            : base(viewReference)
        {
            UPMInBoxPage page = new UPMInBoxPage(StringIdentifier.IdentifierWithStringId("Inbox"))
            {
                Invalid = true,
                SkipUploadIfPossible = viewReference.ContextValueIsSet("SkipUploadPageIfPossible")
            };

            this.removeUploadedFileFromInbox = viewReference.ContextValueIsSet("RemoveUploadedFile");
            this.TopLevelElement             = page;
            this.editFieldContexts           = new Dictionary <StringIdentifier, UPEditFieldContext>();
            IConfigurationUnitStore configStore      = ConfigurationUnitStore.DefaultStore;
            FieldControl            editFieldControl = configStore.FieldControlByNameFromGroup("Edit", viewReference.ContextValueForKey("UploadFields"));
            UPMGroup uploadFieldGroup = new UPMGroup(StringIdentifier.IdentifierWithStringId("uploadFieldGroup"));

            if (editFieldControl != null)
            {
                int numberOfFields = editFieldControl.NumberOfFields;
                for (int index = 0; index < numberOfFields; index++)
                {
                    UPConfigFieldControlField field                 = editFieldControl.FieldAtIndex(index);
                    StringIdentifier          fieldIdentifier       = StringIdentifier.IdentifierWithStringId($"Field {field.FieldId} {field.InfoAreaId}");
                    UPEditFieldContext        initialValueEditField = UPEditFieldContext.FieldContextFor(field, fieldIdentifier, null, (List <UPEditFieldContext>)null);
                    this.editFieldContexts[fieldIdentifier] = initialValueEditField;
                    if (field.Function == "Filename")
                    {
                        page.FileNameEditField = initialValueEditField.EditField;
                    }

                    uploadFieldGroup.AddField(initialValueEditField.EditField);
                }
            }

            this.recordIdentification = this.ViewReference.ContextValueForKey("RecordId");
            page.UploadFieldGroup     = uploadFieldGroup; // load directly
            this.UpdatedElement(page);
        }
예제 #12
0
        /// <summary>
        /// Applies the result row.
        /// </summary>
        /// <param name="row">The row.</param>
        /// <returns></returns>
        public override UPMGroup ApplyResultRow(UPCRMResultRow row)
        {
            IConfigurationUnitStore configStore = ConfigurationUnitStore.DefaultStore;
            UPMStandardGroup        detailGroup = null;
            int fieldCount = this.LayoutTab.FieldCount;
            List <UPEditFieldContext> editFieldContextArray = new List <UPEditFieldContext>(fieldCount);

            for (int j = 0; j < fieldCount; j++)
            {
                WebConfigLayoutField fieldDef        = this.LayoutTab.FieldAtIndex(j);
                IIdentifier          fieldIdentifier = StringIdentifier.IdentifierWithStringId(fieldDef.ValueName);
                string             fieldValue        = configStore.ConfigValue(fieldDef.ValueName);
                UPEditFieldContext editFieldContext  = UPEditFieldContext.FieldContextForWebConfigParameterFieldIdentifierValue(fieldDef, fieldIdentifier, fieldValue);
                if (editFieldContext == null)
                {
                    continue;
                }

                editFieldContextArray.Add(editFieldContext);
                if (detailGroup == null)
                {
                    detailGroup           = new UPMStandardGroup(StringIdentifier.IdentifierWithStringId($"{this.Layout.UnitName}_{this.TabIndex}"));
                    detailGroup.LabelText = this.TabLabel;
                }

                foreach (UPMEditField editField in editFieldContext.EditFields)
                {
                    detailGroup.AddField(editField);
                }
            }

            this.EditFieldContexts = editFieldContextArray;
            this.Group             = detailGroup;
            this.ControllerState   = (detailGroup == null) ? GroupModelControllerState.Empty : GroupModelControllerState.Finished;
            return(detailGroup);
        }
        private UPMStandardGroup CreateNewGroupRecordAsNew(Dictionary <string, object> parentInitialValues, UPCRMRecord record, bool asNew)
        {
            UPContainerMetaInfo metaInfo = new UPContainerMetaInfo(this.ChildFieldControl);
            UPCRMResult         result   = !string.IsNullOrEmpty(record?.RecordId) ? metaInfo.NewRecordWithRecordId(record.RecordId) : metaInfo.NewRecord();

            UPCRMResultRow     childRow         = (UPCRMResultRow)result.ResultRowAtIndex(0);
            UPChildEditContext childEditContext = new UPChildEditContext(childRow, this.NextPostfix);

            if (asNew)
            {
                childEditContext.SetAsNew();
            }

            if (record != null)
            {
                childEditContext.AddChangedLinksFromRecordParentLink(record, null);
            }

            FieldControlTab childFieldControlTab = this.ChildFieldControl.TabAtIndex(0);

            this.combinedInitialValues = null;
            if (this.initialValues != null)
            {
                if (parentInitialValues != null)
                {
                    Dictionary <string, object> combined = new Dictionary <string, object>(this.initialValues);
                    foreach (var item in parentInitialValues)
                    {
                        combined[item.Key] = item.Value;
                    }

                    this.combinedInitialValues = combined;
                }
                else
                {
                    this.combinedInitialValues = this.initialValues;
                }
            }
            else
            {
                this.combinedInitialValues = parentInitialValues;
            }

            List <UPCRMRecord> initialRecords = record != null ? new List <UPCRMRecord> {
                record
            } : null;

            List <object> editFieldContextArray = this.EditContextsFor(childRow, childFieldControlTab,
                                                                       childEditContext.EditFieldContext, this.combinedInitialValues, initialRecords);
            int editFieldCount = editFieldContextArray.Count;

            if (editFieldCount > 0)
            {
                UPMStandardGroup group = new UPMStandardGroup(new RecordIdentifier(childRow.RootRecordIdentification));
                group.Deletable        = true;
                childEditContext.Group = group;
                this.AddChildRecordContext(childEditContext);
                for (int j = 0; j < editFieldCount; j++)
                {
                    UPEditFieldContext editFieldContext = editFieldContextArray[j] as UPEditFieldContext;
                    if (editFieldContext != null)
                    {
                        editFieldContext.ChildEditContext  = childEditContext;
                        editFieldContext.FieldLabelPostfix = childEditContext.FieldLabelPostfix;
                        List <UPMEditField> editFields = editFieldContext.EditFields;
                        if (editFields.Count > 0)
                        {
                            foreach (UPMEditField editField in editFields)
                            {
                                editField.EditFieldsContext = childEditContext;
                                group.AddField(editField);
                            }
                        }
                        else
                        {
                            UPMField field = editFieldContext.Field;
                            if (field != null)
                            {
                                group.AddField(field);
                            }
                        }
                    }
                    else
                    {
                        group.AddField((UPMField)editFieldContextArray[j]);
                    }
                }

                childEditContext.HandleDependentFields();
                return(group);
            }

            return(null);
        }
        /// <summary>
        /// Changeds the records for context new record link user changes only.
        /// </summary>
        /// <param name="childEditContext">The child edit context.</param>
        /// <param name="newRecord">if set to <c>true</c> [new record].</param>
        /// <param name="link">The link.</param>
        /// <param name="userChangesOnly">if set to <c>true</c> [user changes only].</param>
        /// <returns></returns>
        public List <UPCRMRecord> ChangedRecordsForContextNewRecordLinkUserChangesOnly(UPChildEditContext childEditContext, bool newRecord, UPCRMLink link, bool userChangesOnly)
        {
            if (childEditContext.DeleteRecord)
            {
                if (newRecord)
                {
                    return(null);
                }

                UPCRMRecord record = new UPCRMRecord(childEditContext.RecordIdentification);
                record.Deleted = true;
                return(new List <UPCRMRecord> {
                    record
                });
            }

            Dictionary <string, UPEditFieldContext> changedFields = null;

            if (newRecord && !userChangesOnly)
            {
                if (this.combinedInitialValues != null)
                {
                    foreach (string fieldIdentification in this.combinedInitialValues.Keys)
                    {
                        int fieldId = fieldIdentification.FieldIdFromStringWithInfoAreaId(this.ChildInfoAreaId);
                        if (fieldId >= 0)
                        {
                            UPEditFieldContext initialValueEditField = new UPEditFieldContext(fieldId, this.combinedInitialValues[fieldIdentification] as string);
                            if (changedFields == null)
                            {
                                changedFields = new Dictionary <string, UPEditFieldContext> {
                                    { initialValueEditField.Key, initialValueEditField }
                                };
                            }
                            else
                            {
                                changedFields.SetObjectForKey(initialValueEditField, initialValueEditField.Key);
                            }
                        }
                    }
                }
            }

            foreach (UPEditFieldContext editFieldContext in childEditContext.EditFieldContext.Values)
            {
                if (editFieldContext.WasChanged(userChangesOnly))
                {
                    if (changedFields != null)
                    {
                        changedFields.SetObjectForKey(editFieldContext, editFieldContext.Key);
                    }
                    else
                    {
                        changedFields = new Dictionary <string, UPEditFieldContext> {
                            { editFieldContext.Key, editFieldContext }
                        };
                    }
                }
            }

            List <UPCRMRecord>      additionalRecords = null;
            ICollection <UPCRMLink> changedLinks      = (ICollection <UPCRMLink>)childEditContext.ChangedLinkArray ?? new List <UPCRMLink>();

            if (changedFields?.Count > 0 || changedLinks?.Count > 0)
            {
                UPCRMRecord record;
                if (newRecord)
                {
                    record = childEditContext.RecordIdentification.RecordId().Length > 6
                        ? new UPCRMRecord(childEditContext.RecordIdentification)
                        : UPCRMRecord.CreateNew(childEditContext.RecordIdentification.InfoAreaId());

                    record.AddLink(link);
                    UPConfigFilter createFilter = ConfigurationUnitStore.DefaultStore.FilterByName($"{record.InfoAreaId}.ChildCreateTemplate");
                    createFilter      = createFilter.FilterByApplyingDefaultReplacements();
                    additionalRecords = record.ApplyValuesFromTemplateFilter(createFilter, false);
                }
                else
                {
                    record = new UPCRMRecord(childEditContext.RecordIdentification);
                }

                foreach (UPEditFieldContext changedField in changedFields.Values)
                {
                    if (newRecord)
                    {
                        record.NewValueFieldId(changedField.Value, changedField.FieldId);
                    }
                    else
                    {
                        record.NewValueFromValueFieldId(changedField.Value, changedField.OriginalValue, changedField.FieldId);
                    }
                }

                foreach (UPCRMLink changedLink in changedLinks)
                {
                    record.AddLink(changedLink);
                }

                if (additionalRecords?.Count > 0)
                {
                    List <UPCRMRecord> arr = new List <UPCRMRecord> {
                        record
                    };
                    arr.AddRange(additionalRecords);
                    return(arr);
                }

                return(new List <UPCRMRecord> {
                    record
                });
            }

            return(null);
        }
예제 #15
0
        private void FillPage()
        {
            UPMCharacteristicsPage newPage = (UPMCharacteristicsPage)this.InstantiatePage();

            newPage.IsReadOnly = this.IsReadOnly;
            foreach (UPCharacteristicsGroup crmGroup in this.Characteristics.Groups)
            {
                UPMCharacteristicsItemGroup group = new UPMCharacteristicsItemGroup(StringIdentifier.IdentifierWithStringId(crmGroup.CatalogValue))
                {
                    GroupNameField = new UPMStringField(StringIdentifier.IdentifierWithStringId(crmGroup.Label))
                    {
                        StringValue = crmGroup.Label
                    },
                    ShowExpanded = crmGroup.ShowExpanded,
                    GroupType    = crmGroup.SingleSelection ? UPMCharacteristicsItemGroupType.SingleSelect : UPMCharacteristicsItemGroupType.MultiSelect
                };

                foreach (UPCharacteristicsItem crmItem in crmGroup.Items)
                {
                    UPMCharacteristicsItem item = new UPMCharacteristicsItem(StringIdentifier.IdentifierWithStringId(crmItem.CatalogValue))
                    {
                        ItemNameField = new UPMStringField(StringIdentifier.IdentifierWithStringId(crmItem.Label))
                        {
                            StringValue = crmItem.Label
                        },
                        SelectedField = new UPMBooleanEditField(StringIdentifier.IdentifierWithStringId(crmItem.Label))
                        {
                            BoolValue = crmItem.Record != null
                        }
                    };
                    group.AddChild(item);

                    List <UPMField> additionalEditFields = new List <UPMField>();
                    if (crmItem.ShowAdditionalFields)
                    {
                        for (int additionalFieldIndex = 0; additionalFieldIndex < crmItem.AdditionalFields.Count; additionalFieldIndex++)
                        {
                            UPConfigFieldControlField configField     = crmItem.AdditionalFields[additionalFieldIndex];
                            FieldIdentifier           fieldIdentifier = FieldIdentifier.IdentifierWithRecordIdentificationFieldId(this.CharacteristicsRootRecordIdentification, configField.Identification);
                            UPEditFieldContext        fieldContext    = UPEditFieldContext.FieldContextFor(configField, fieldIdentifier, crmItem.Values[additionalFieldIndex], (List <UPEditFieldContext>)null);
                            if (fieldContext != null)
                            {
                                additionalEditFields.Add(fieldContext.EditField);
                                this.editPageContext.EditFields.SetObjectForKey(fieldContext, $"{configField.Identification}-{crmItem.CatalogValue}-{crmGroup.CatalogValue}");
                            }
                        }
                    }

                    item.EditFields = additionalEditFields;
                }

                if (group.Children.Count > 0)
                {
                    newPage.AddChild(group);
                }
            }

            if (this.IsReadOnly)
            {
                newPage = this.PageForOverview(newPage);
            }

            ITopLevelElement oldPage = this.TopLevelElement;

            this.TopLevelElement = newPage;
            newPage.Invalid      = false;
            this.InformAboutDidChangeTopLevelElement(oldPage, newPage, null, null);
        }
예제 #16
0
        private void LoadData(UPMObjectivesPage objectivesPage)
        {
            int itemCounter    = 0;
            int sectionCounter = 0;

            foreach (UPObjectivesGroup group in this.objectivesGroupArray)
            {
                UPMObjectivesSection section = this.CreateSectionIdentfier(group.Label, StringIdentifier.IdentifierWithStringId(group.GroupKey));
                foreach (UPObjectivesItem item in group.Items)
                {
                    UPMObjective mobjective = this.CreateObjectiveIdentfier(item, StringIdentifier.IdentifierWithStringId($"ObjectiveItem_{itemCounter}"));
                    if (item.Documents != null)
                    {
                        UPMDocumentsGroup documentGroup = new UPMDocumentsGroup(StringIdentifier.IdentifierWithStringId($"documentgroup{itemCounter}"));
                        foreach (DocumentData document in item.Documents)
                        {
                            UPMDocument documentModel = new UPMDocument(document);
                            documentGroup.AddChild(documentModel);
                        }

                        mobjective.AddGroup(documentGroup);
                    }

                    mobjective.ObjectiveItem = item;
                    Dictionary <string, UPEditFieldContext> itemEditFields = new Dictionary <string, UPEditFieldContext>();
                    for (int additionalFieldIndex = 0; additionalFieldIndex < item.AdditionalFields.Count; additionalFieldIndex++)
                    {
                        UPConfigFieldControlField field           = item.AdditionalFields[additionalFieldIndex];
                        RecordIdentifier          fieldIdentifier = new RecordIdentifier(field.Identification);
                        UPEditFieldContext        fieldContext    = null;
                        FieldAttributes           attributes      = field.Attributes;
                        if (attributes != null && attributes.Hide)
                        {
                            fieldContext = UPEditFieldContext.HiddenFieldFor(field, fieldIdentifier, item.Values[additionalFieldIndex]);
                        }
                        else if (attributes != null && attributes.ReadOnly)
                        {
                            fieldContext = UPEditFieldContext.ReadonlyFieldFor(field, fieldIdentifier, item.Values[additionalFieldIndex]);
                        }
                        else
                        {
                            fieldContext = UPEditFieldContext.FieldContextFor(field, fieldIdentifier, item.Values[additionalFieldIndex], (List <UPEditFieldContext>)null);
                        }

                        if (fieldContext?.Field != null)
                        {
                            string fieldIdentification = this.FieldIdentificationSectionCounterItemCounter(field.Field, sectionCounter, itemCounter);
                            this.editPageContext.EditFields.SetObjectForKey(fieldContext, fieldIdentification);
                            itemEditFields.SetObjectForKey(fieldContext, fieldIdentification);
                            if (fieldContext.EditField != null)
                            {
                                fieldContext.EditField.EditFieldsContext = this.editPageContext;
                                mobjective.AddField(fieldContext.EditField);
                            }
                            else
                            {
                                mobjective.AddField(fieldContext.Field);
                            }
                        }
                    }

                    this.HandleDependentFieldsSectionCounterItemCounter(itemEditFields, sectionCounter, itemCounter);
                    if (item.ButtonActions.Count > 0)
                    {
                        List <UPMOrganizerAction> buttonActions = new List <UPMOrganizerAction>();
                        foreach (UPConfigButton button in item.ButtonActions)
                        {
                            StringIdentifier   fieldIdentifier = StringIdentifier.IdentifierWithStringId("button");
                            UPMOrganizerAction action          = new UPMOrganizerAction(fieldIdentifier);
                            //action.SetTargetAction(this.ParentOrganizerModelController, PerformObjectivesAction);
                            action.ViewReference = button.ViewReference.ViewReferenceWith(item.Record.RecordIdentification);
                            action.LabelText     = button.Label;
                            buttonActions.Add(action);
                        }

                        mobjective.Actions = buttonActions;
                    }

                    section.AddChild(mobjective);
                    itemCounter++;
                }

                if (section.Children.Count > 0)
                {
                    objectivesPage.AddChild(section);
                }
            }

            if (objectivesPage.Children.Count == 0)
            {
                UPMMessageStatus messageStatus = new UPMMessageStatus(StringIdentifier.IdentifierWithStringId("messageIdentifier"));
                UPMStringField   messageField  = new UPMStringField(StringIdentifier.IdentifierWithStringId("statusFieldIdentifier"));
                messageField.FieldValue          = LocalizedString.Localize(LocalizationKeys.TextGroupBasic, LocalizationKeys.KeyBasicNoObjectives);
                messageStatus.DetailMessageField = messageField;
                objectivesPage.Status            = messageStatus;
            }
        }
예제 #17
0
        /// <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);
        }
예제 #18
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UPEditConstraintViolation"/> class.
 /// </summary>
 /// <param name="context">
 /// The context.
 /// </param>
 /// <param name="violationType">
 /// Type of the violation.
 /// </param>
 public UPEditConstraintViolation(UPEditFieldContext context, EditConstraintViolationType violationType)
     : this(context, violationType, null)
 {
 }