public void CSOMItemField_Test_GetRequestParameters_TaxonomyMulti()
        {
            FieldValueCollection taxFieldCollection = new FieldValueCollection(new Field()
            {
                TypeAsString = "TaxonomyFieldTypeMulti"
            }, "SomeTestField");

            taxFieldCollection.Values.Add(new FieldTaxonomyValue()
            {
                Label  = "Legal",
                WssId  = -1,
                TermId = Guid.Parse("4a699f99-8a47-40f3-8ae3-656e468d7861")
            });
            taxFieldCollection.Values.Add(new FieldTaxonomyValue()
            {
                Label  = "People",
                WssId  = -1,
                TermId = Guid.Parse("45193e31-5fed-4662-b51d-09ed6037ff37")
            });
            CSOMItemField field = new CSOMItemField()
            {
                FieldName  = "SomeTestField",
                FieldValue = taxFieldCollection
            };
            var    parameters         = field.GetRequestParameters(1);
            string parameterReference = parameters[0].SerializeParameter();
            string parameterValue     = parameters[1].SerializeParameter();

            Assert.AreEqual("<Parameter Type=\"String\">-1;#Legal|4a699f99-8a47-40f3-8ae3-656e468d7861;#-1;#People|45193e31-5fed-4662-b51d-09ed6037ff37</Parameter>", parameterValue);
            Assert.AreEqual("<Parameter ObjectPathId=\"1\" />", parameterReference);
        }
Example #2
0
        /// <summary>
        /// Converte o widget para uma instância de Field.
        /// </summary>
        public Field ToMediaField()
        {
            var field = new Field();

            field.CopyFrom(this);
            field.Properties = new FieldProperties();
            field.Properties.CopyFrom(this);

            // Verificando se o widget da suporte à interface IHasOptions<TOption>
            var options = field.Get <IEnumerable>("Options");

            if (options != null)
            {
                var values = field.Get <object[]>("Value");
                if (values == null)
                {
                    var value = field.Get("Value");
                    values = value.AsSingle().NonNull().ToArray();
                }

                var fieldValues = new FieldValueCollection();
                foreach (Option option in options)
                {
                    var fieldValue = new FieldValue();
                    fieldValue.CopyFrom(options);
                    fieldValue.Selected = values.Contains(option.Value);
                }
                field.Value = fieldValues;
            }

            return(field);
        }
Example #3
0
 private string GetFieldType()
 {
     if (FieldValue is FieldValueCollection)
     {
         FieldValueCollection collection = FieldValue as FieldValueCollection;
         string typeAsString             = collection.TypeAsString;
         if (string.IsNullOrEmpty(typeAsString))
         {
             var firstElement = collection.Values.FirstOrDefault();
             if (firstElement is FieldLookupValue)
             {
                 return("LookupMulti");
             }
             else if (firstElement is FieldTaxonomyValue)
             {
                 return("TaxonomyFieldTypeMulti");
             }
         }
         return(typeAsString);
     }
     return(FieldValue?.GetType().Name);
 }
        public void CSOMItemField_Test_GetRequestParameters_LookupMulti()
        {
            FieldValueCollection lookupCollection = new FieldValueCollection(new Field()
            {
                TypeAsString = "LookupMulti"
            }, "SomeTestField");

            lookupCollection.Values.Add(new FieldLookupValue()
            {
                LookupId = 2
            });
            lookupCollection.Values.Add(new FieldLookupValue()
            {
                LookupId = 3
            });
            CSOMItemField field = new CSOMItemField()
            {
                FieldName  = "SomeTestField",
                FieldValue = lookupCollection
            };
            var    parameters           = field.GetRequestParameters();
            string parameterDeclaration = parameters[0].SerializeParameter();
            string parameterValue       = parameters[1].SerializeParameter();

            Assert.AreEqual("<Parameter Type=\"String\">SomeTestField</Parameter>", parameterDeclaration);
            Assert.AreEqual($"<Parameter Type=\"Array\">" +
                            "<Object TypeId=\"{f1d34cc0-9b50-4a78-be78-d5facfcccfb7}\">" +
                            "<Property Name=\"LookupId\" Type=\"Int32\">2</Property>" +
                            "<Property Name=\"LookupValue\" Type=\"Null\" />" +
                            "</Object>" +
                            "<Object TypeId=\"{f1d34cc0-9b50-4a78-be78-d5facfcccfb7}\">" +
                            "<Property Name=\"LookupId\" Type=\"Int32\">3</Property>" +
                            "<Property Name=\"LookupValue\" Type=\"Null\" />" +
                            "</Object>" +
                            "</Parameter>", parameterValue);
        }
Example #5
0
        /// <summary>
        /// Gets the fields of the current row.
        /// </summary>
        /// <param name="grbit">The grbit.</param>
        /// <returns>A <see cref="FieldCollection"/> object to allow retrieval of all fields of the current row.</returns>
        internal FieldCollection GetFields(RetrieveColumnGrbit grbit)
        {
            JET_PFNREALLOC allocator =
                (context, pv, cb) =>
                IntPtr.Zero == pv ? Marshal.AllocHGlobal(new IntPtr(cb)) : Marshal.ReAllocHGlobal(pv, new IntPtr(cb));

            lock (this.isamSession)
            {
                this.CheckDisposed();
                this.CheckRecord();

                EnumerateColumnsGrbit enumerateGrbit = ((grbit & RetrieveColumnGrbit.RetrieveCopy) != 0)
                                                           ? EnumerateColumnsGrbit.EnumerateCopy
                                                           : EnumerateColumnsGrbit.None;

                using (IsamTransaction trx = new IsamTransaction(this.isamSession, true))
                {
                    // enumerate all field values in the current record or copy
                    // buffer
                    JET_ENUMCOLUMN[] jecs;
                    int numColumnValues;
                    Api.JetEnumerateColumns(
                        this.isamSession.Sesid,
                        this.tableid,
                        0, // numColumnids
                        null, // columnids
                        out numColumnValues,
                        out jecs,
                        allocator,
                        IntPtr.Zero, // allocatorContext,
                        int.MaxValue,
                        enumerateGrbit);

                    // create a field collection to contain our field values
                    FieldCollection fields = new FieldCollection();

                    // save the location of the source record for these field values
                    fields.Location = this.Location;

                    // fill the field collection with our field values
                    if (jecs != null && jecs.Length > 0)
                    {
                        foreach (JET_ENUMCOLUMN jec in jecs)
                        {
                            if (jec.rgEnumColumnValue != null && jec.rgEnumColumnValue.Length > 0)
                            {
                                JET_COLUMNBASE columnbase;
                                VistaApi.JetGetTableColumnInfo(
                                    this.isamSession.Sesid,
                                    this.tableid,
                                    jec.columnid,
                                    out columnbase);

                                Columnid columnid = new Columnid(columnbase);
                                bool isAscii = columnbase.cp == JET_CP.ASCII;
                                FieldValueCollection values = new FieldValueCollection(columnid);
                                foreach (JET_ENUMCOLUMNVALUE jecv in jec.rgEnumColumnValue)
                                {
                                    // FUTURE-2013/11/15-martinc: Drat, this is an IntPtr, and ObjectFromBytes() really
                                    // wants a byte[] array. Copying the data to a byte array just to simply
                                    // re-interpret it as an object is inefficient.
                                    // We should write Converter.ObjectFromIntPtr...
                                    byte[] bytesData = new byte[jecv.cbData];
                                    Marshal.Copy(jecv.pvData, bytesData, 0, bytesData.Length);

                                    values.Add(Converter.ObjectFromBytes(columnbase.coltyp, isAscii, bytesData));
                                }

                                values.ReadOnly = true;
                                fields.Add(values);
                            }
                        }
                    }

                    fields.ReadOnly = true;

                    // Return the field collection.
                    return fields;
                }
            }
        }