public bool Bind()
        {
            if (existing == null)
            {
                return(false);
            }
            if (update == null)
            {
                return(false);
            }

            if (modelProperties.GetLocation(existing) != modelProperties.GetLocation(update))
            {
                return(false);
            }

            SubmitDataRecord record = new SubmitDataRecord
            {
                Location      = modelProperties.GetLocation(existing),
                Module        = modelProperties.Module,
                MergeCriteria = new MergeCriteria
                {
                    SetId = ModelIdentifier.GetValue <TModel, long>(update)
                }
            };

            List <Field> fields = new List <Field>();

            foreach (FieldMapping fieldMapping in amplaViewProperties.GetFieldMappings())
            {
                if (fieldMapping.CanWrite)
                {
                    string existingField;
                    string updateField;
                    if (fieldMapping.TryResolveValue(modelProperties, existing, out existingField) &&
                        fieldMapping.TryResolveValue(modelProperties, update, out updateField))
                    {
                        if (updateField != existingField)
                        {
                            Field field = new Field {
                                Name = fieldMapping.Name, Value = updateField
                            };
                            fields.Add(field);
                        }
                    }
                }
            }
            if (fields.Count > 0)
            {
                record.Fields = fields.ToArray();
                records.Add(record);
            }

            return(records.Count > 0);
        }
        public bool Bind()
        {
            if (models.Count == 0)
            {
                return(false);
            }

            foreach (TModel model in models)
            {
                UpdateRecordStatus record = new UpdateRecordStatus
                {
                    Location = modelProperties.GetLocation(model),
                    Module   = modelProperties.Module,

                    MergeCriteria = new UpdateRecordStatusMergeCriteria
                    {
                        SetId = ModelIdentifier.GetValue <TModel, long>(model)
                    },
                    RecordAction = recordAction
                };
                records.Add(record);
            }

            return(true);
        }
示例#3
0
        /// <summary>
        /// Validates the specified model location is the specified value.
        /// </summary>
        /// <param name="modelProperties">The model properties.</param>
        /// <param name="model">The model.</param>
        /// <param name="validationMessages">The validation messages.</param>
        /// <returns></returns>
        public bool Validate(IModelProperties <TModel> modelProperties, TModel model, ValidationMessages validationMessages)
        {
            string newlocation = modelProperties.GetLocation(model);

            bool isValid = string.Compare(location, newlocation, StringComparison.InvariantCulture) == 0;

            if (!isValid)
            {
                validationMessages.Add("The Location property is not the required value: " + location);
            }
            return(isValid);
        }
示例#4
0
        public bool Bind()
        {
            if (models.Count == 0)
            {
                return(false);
            }

            foreach (TModel model in models)
            {
                SubmitDataRecord record = new SubmitDataRecord
                {
                    Location      = modelProperties.GetLocation(model),
                    Module        = modelProperties.Module,
                    MergeCriteria = null
                };

                List <Field> fields = new List <Field>();
                foreach (FieldMapping fieldMapping in amplaViewProperties.GetFieldMappings())
                {
                    if (fieldMapping.CanWrite)
                    {
                        string value;
                        if (fieldMapping.TryResolveValue(modelProperties, model, out value))
                        {
                            Field field = new Field {
                                Name = fieldMapping.Name, Value = value
                            };
                            fields.Add(field);
                        }
                    }
                }
                if (fields.Count > 0)
                {
                    record.Fields = fields.ToArray();
                    records.Add(record);
                }
            }

            return(records.Count > 0);
        }