/// <summary> /// Turns the object into an ObjectInstance /// </summary> public static ObjectInstance ToObjectInstance(this object o, ScriptEngine engine) { var result = engine.Object.Construct(); if (o.GetType() == typeof(ObjectInstance)) { return(o as ObjectInstance); //shouldn't have to... but just in case } if (o.GetType() == typeof(NameValueCollection) || o.GetType().IsSubclassOf(typeof(NameValueCollection))) { var nv = (NameValueCollection)o; nv.Cast <string>().Select(key => new KeyValuePair <string, object>(key, nv[key])).ToList().ForEach(i => result.SetPropertyValue(i.Key, i.Value, false)); } else { var props = o.GetType().GetProperties(); foreach (var item in props) { //TODO: Be more smart about the types? (should only be primitives, but could be something else) var value = item.GetValue(o, null); if (value is DateTime) { value = JurassicHelper.ToDateInstance(engine, (DateTime)value); } result.SetPropertyValue(item.Name, value, false); } } return(result); }
public SPFeatureInstance ActivateFeature(object feature, object force) { var featureId = Guid.Empty; if (feature is string) { featureId = new Guid(feature as string); } else if (feature is GuidInstance) { featureId = (feature as GuidInstance).Value; } else if (feature is SPFeatureInstance) { featureId = (feature as SPFeatureInstance).Feature.DefinitionId; } else if (feature is SPFeatureDefinitionInstance) { featureId = (feature as SPFeatureDefinitionInstance).FeatureDefinition.Id; } if (featureId == Guid.Empty) { return(null); } var forceValue = JurassicHelper.GetTypedArgumentValue(Engine, force, false); var activatedFeature = m_site.Features.Add(featureId, forceValue); return(new SPFeatureInstance(Engine.Object.InstancePrototype, activatedFeature)); }
public ArrayInstance ListEntities(object filterCriteria) { var criteria = new EntityFilterCriteriaInstance(Engine.Object.InstancePrototype); if (filterCriteria is FolderInstance) { criteria.EntityFilterCriteria.Path = (filterCriteria as FolderInstance).FullPath; } else if (filterCriteria is string || filterCriteria is StringInstance || filterCriteria is ConcatenatedString) { criteria.EntityFilterCriteria.Path = filterCriteria.ToString(); } else if (filterCriteria != null && filterCriteria != Null.Value && filterCriteria != Undefined.Value) { criteria = JurassicHelper.Coerce <EntityFilterCriteriaInstance>(Engine, filterCriteria); } var result = Engine.Array.Construct(); foreach (var entity in m_repository.ListEntities(criteria.EntityFilterCriteria)) { ArrayInstance.Push(result, new EntityInstance(Engine, entity)); } return(result); }
public SortInstance AddSortField( [JSDoc("(string) Name of the field to sort by")] string fieldName, [JSDoc("(bool) (Optional) Indicates whether or not to reverse the sort (false is ascending, true is descending). Default is false.")] object reverse, [JSDoc("(string) (Optional) Indicates the field type to sort by. Possible values are: string, byte, double, float, int, long, short, string value, doc and score. Default is score.")] object fieldType) { if (fieldName.IsNullOrWhiteSpace()) { throw new JavaScriptException(this.Engine, "Error", "A field name must be specified as the first argument."); } var reverseValue = JurassicHelper.GetTypedArgumentValue(this.Engine, reverse, false); var fieldTypeValue = JurassicHelper.GetTypedArgumentValue(this.Engine, fieldType, "string"); SortFieldType fieldTypeEnum; if (fieldTypeValue.TryParseEnum(true, out fieldTypeEnum) == false) { fieldTypeEnum = SortFieldType.String; } Sort.SortFields.Add(new SortField { FieldName = fieldName, Reverse = reverseValue, Type = fieldTypeEnum, }); return(this); }
public NumericRangeQueryInstance <float> CreateFloatRangeQuery(string fieldName, object min, object max, bool minInclusive, bool maxInclusive) { float?floatMin; if (min == null || min == Null.Value || min == Undefined.Value) { floatMin = null; } else { floatMin = JurassicHelper.GetTypedArgumentValue(Engine, min, 0); } float?floatMax; if (max == null || max == Null.Value || max == Undefined.Value) { floatMax = null; } else { floatMax = JurassicHelper.GetTypedArgumentValue(Engine, max, 0); } var query = new FloatNumericRangeQuery { FieldName = fieldName, Min = floatMin, Max = floatMax, MinInclusive = minInclusive, MaxInclusive = maxInclusive }; return(new NumericRangeQueryInstance <float>(Engine.Object.InstancePrototype, query)); }
public int Count(object countParams) { var parameters = new CountParams(this.Engine.Object.InstancePrototype); if (countParams != null && countParams != Null.Value && countParams != Undefined.Value) { parameters = JurassicHelper.Coerce <CountParams>(this.Engine, countParams); } if (String.IsNullOrEmpty(parameters.TableName)) { parameters.TableName = GetFullTableName(); } if (String.IsNullOrEmpty(parameters.TableName)) { throw new JavaScriptException(this.Engine, "Error", "A table name must be specified either as a parameter or via the tableName property on the DynamicModel instance."); } if (String.IsNullOrEmpty(parameters.Where)) { return((int)Scalar(String.Format("SELECT COUNT(*) FROM {0}", parameters.TableName))); } return((int)Scalar(String.Format("SELECT COUNT(*) FROM {0} WHERE {1}", parameters.TableName, parameters.Where))); }
public object Single(object filterCriteria) { var criteria = new EntityFilterCriteriaInstance(Engine.Object.InstancePrototype); if (filterCriteria is FolderInstance) { criteria.EntityFilterCriteria.Path = (filterCriteria as FolderInstance).FullPath; } else if (filterCriteria is string || filterCriteria is StringInstance || filterCriteria is ConcatenatedString) { criteria.EntityFilterCriteria.Path = filterCriteria.ToString(); } else if (filterCriteria != null && filterCriteria != Null.Value && filterCriteria != Undefined.Value) { criteria = JurassicHelper.Coerce <EntityFilterCriteriaInstance>(Engine, filterCriteria); } var result = m_repository.Single(criteria.EntityFilterCriteria); if (result == null) { return(Null.Value); } return(new EntityInstance(Engine, result)); }
public object Bundle(string bundleDefinitionXml, string fileName, object update, object minify) { if (String.IsNullOrEmpty(fileName)) { fileName = "bundle.txt"; } var bUpdate = JurassicHelper.GetTypedArgumentValue(Engine, update, true); var bMinify = JurassicHelper.GetTypedArgumentValue(Engine, minify, false); var doc = new XmlDocument(); doc.LoadXml(bundleDefinitionXml); var bundleText = GenerateBundleFromBundleDefinition(fileName, doc, bUpdate, bMinify); var bytes = new Base64EncodedByteArrayInstance(Engine.Object.InstancePrototype, Encoding.UTF8.GetBytes(bundleText)) { FileName = fileName, MimeType = StringHelper.GetMimeTypeFromFileName(fileName), }; var result = Engine.Object.Construct(); result.SetPropertyValue("lastModified", JurassicHelper.ToDateInstance(Engine, FileModifiedDates.Values.Max(v => v.Item1)), false); result.SetPropertyValue("data", bytes, false); return(result); }
public void LoadFromJson(object array, object hasHeader) { if (array == null || array == Null.Value || array == Undefined.Value || (array is ArrayInstance) == false || (array as ArrayInstance).Length == 0) { return; } var jsonArray = array as ArrayInstance; var bHasHeader = JurassicHelper.GetTypedArgumentValue(this.Engine, hasHeader, true); List <string> header = null; //If we have a header, populate the first row with header info. var currentRow = 1; if (bHasHeader) { var firstRecord = jsonArray[0] as ObjectInstance; if (firstRecord == null) { return; } header = firstRecord.Properties .Select(property => property.Name) .ToList(); for (int i = 1; i < header.Count + 1; i++) { m_excelWorksheet.Cells[currentRow, i].Value = header[i - 1]; } currentRow++; } foreach (var value in jsonArray.ElementValues.OfType <ObjectInstance>()) { if (header == null) { var properties = value.Properties.ToList(); for (var c = 1; c < properties.Count + 1; c++) { var propertyValue = properties[c - 1]; SetValue(currentRow, c, propertyValue.Value); } } else { for (var c = 1; c < header.Count + 1; c++) { var key = header[c - 1]; var propertyValue = value[key]; SetValue(currentRow, c, propertyValue); } } currentRow++; } }
public DocumentStoreInstance Construct(object creationInfo) { if (creationInfo != null && creationInfo != Null.Value && creationInfo != Undefined.Value && creationInfo is ObjectInstance) { var result = JurassicHelper.Coerce <DocumentStoreInstance>(this.Engine, creationInfo); return(result); } return(new DocumentStoreInstance(this.InstancePrototype)); }
public static double Utc(ScriptEngine engine, int year, int month, [DefaultParameterValue(1)] object dayArg, [DefaultParameterValue(0)] object hourArg, [DefaultParameterValue(0)] object minuteArg, [DefaultParameterValue(0)] object secondArg, [DefaultParameterValue(0)] object millisecondArg) { var day = JurassicHelper.GetTypedArgumentValue(engine, dayArg, 1); var hour = JurassicHelper.GetTypedArgumentValue(engine, hourArg, 0); var minute = JurassicHelper.GetTypedArgumentValue(engine, minuteArg, 0); var second = JurassicHelper.GetTypedArgumentValue(engine, secondArg, 0); var millisecond = JurassicHelper.GetTypedArgumentValue(engine, millisecondArg, 0); return(DateInstance.Utc(engine, year, month, day, hour, minute, second, millisecond)); }
public override object CallLateBound(object thisObject, params object[] argumentValues) { var contentObject = argumentValues.ElementAtOrDefault(0); if (contentObject == Undefined.Value || contentObject == Null.Value || contentObject == null) { return(thisObject); } var mergeSettings = argumentValues.ElementAtOrDefault(1); JsonMergeSettingsInstance jms = null; if (mergeSettings != Undefined.Value && mergeSettings != Null.Value && mergeSettings != null) { if (mergeSettings is JsonMergeSettingsInstance) { jms = (mergeSettings as JsonMergeSettingsInstance); } else { jms = JurassicHelper.Coerce <JsonMergeSettingsInstance>(this.Engine, mergeSettings); } } var s1 = JSONObject.Stringify(this.Engine, thisObject, null, null); var s2 = JSONObject.Stringify(this.Engine, contentObject, null, null); if (TypeUtilities.IsObject(thisObject) == false && TypeUtilities.IsArray(thisObject) == false) { throw new JavaScriptException(this.Engine, "Error", "This object must either be an object or an array."); } if (TypeUtilities.IsObject(contentObject) == false && TypeUtilities.IsArray(contentObject) == false) { throw new JavaScriptException(this.Engine, "Error", "Content object must either be an object or an array."); } var o1 = (JContainer)JToken.Parse(s1); var o2 = (JContainer)JToken.Parse(s2); if (jms != null) { o1.Merge(o2, jms.JsonMergeSettings); } else { o1.Merge(o2); } var result = JSONObject.Parse(this.Engine, o1.ToString(), null); return(result); }
public DateInstance GetServerNow(SPWebInstance web) { if (web == null) { throw new JavaScriptException(this.Engine, "Error", "A web must be specified as the first parameter."); } var result = SPUtility.GetServerNow(web.Web); return(JurassicHelper.ToDateInstance(this.Engine, result)); }
public ObjectInstance Paged(object pagedParams) { PagedParams parameters = new PagedParams(this.Engine.Object.InstancePrototype); if (pagedParams != null && pagedParams != Undefined.Value && pagedParams != Null.Value) { parameters = JurassicHelper.Coerce <PagedParams>(this.Engine, pagedParams); } return(BuildPagedResult(parameters)); }
public static ObjectInstance RecordToObjectInstance(this IDataReader rdr, ScriptEngine engine) { ObjectInstance e = engine.Object.Construct(); for (int i = 0; i < rdr.FieldCount; i++) { object propertyValue; var value = rdr[i]; if (DBNull.Value.Equals(value)) { propertyValue = Null.Value; } else if (value is DateTime) { propertyValue = JurassicHelper.ToDateInstance(engine, (DateTime)value); } else if (value is Byte) { propertyValue = Convert.ToInt32((Byte)value); } else if (value is Int16) { propertyValue = Convert.ToInt32((Int16)value); } else if (value is Int64) { propertyValue = Convert.ToDouble((Int64)value); } else if (value is decimal) { propertyValue = Convert.ToDouble((decimal)value); } else if (value is Guid) { propertyValue = ((Guid)value).ToString(); } else if (value is Byte[]) { propertyValue = new Base64EncodedByteArrayInstance(engine.Object.InstancePrototype, (Byte[])value); } else if (value.GetType().FullName == "Microsoft.SqlServer.Types.SqlHierarchyId") { propertyValue = value.ToString(); } else { propertyValue = value; } e.SetPropertyValue(rdr.GetName(i), propertyValue, false); } return(e); }
public int Delete(object deleteParams) { if (deleteParams == null || deleteParams == Null.Value || deleteParams == Undefined.Value) { throw new JavaScriptException(this.Engine, "Error", "Must specify an object with where or key"); } var parameters = JurassicHelper.Coerce <DeleteParams>(this.Engine, deleteParams); int result = Execute(CreateDeleteCommand(parameters)); return(result); }
public ArrayInstance All(object allParams) { var parameters = new AllParams(this.Engine.Object.InstancePrototype); if (allParams != null && allParams != Undefined.Value && allParams != Null.Value) { parameters = JurassicHelper.Coerce <AllParams>(this.Engine, allParams); } string sql = BuildSelect(parameters.Where, parameters.OrderBy, parameters.Limit); return(Query(string.Format(sql, parameters.Columns, GetFullTableName()), parameters.Args)); }
public void Compile(string pattern, [DefaultParameterValue(null)] object flagsArg) { var flags = JurassicHelper.GetTypedArgumentValue <string>(this.Engine, flagsArg, null); this.m_value = new Regex(pattern, ParseFlags(flags) | RegexOptions.Compiled); // Update the javascript properties. this.FastSetProperty("source", pattern, PropertyAttributes.Sealed, false); this.FastSetProperty("global", this.Global, PropertyAttributes.Sealed, false); this.FastSetProperty("multiline", this.Multiline, PropertyAttributes.Sealed, false); this.FastSetProperty("ignoreCase", this.IgnoreCase, PropertyAttributes.Sealed, false); this.LastIndex = 0; }
public string ToStringJS([DefaultParameterValue(10)] object radixArg) { var radix = JurassicHelper.GetTypedArgumentValue(this.Engine, radixArg, 10); // Check the parameter is in range. if (radix < 2 || radix > 36) { throw new JavaScriptException(this.Engine, "RangeError", "The radix must be between 2 and 36, inclusive."); } // NumberFormatter does the hard work. return(NumberFormatter.ToString(this.m_value, radix, NumberFormatter.Style.Regular, 0)); }
public string ToFixed([DefaultParameterValue(0)] object fractionDigitsArg) { var fractionDigits = JurassicHelper.GetTypedArgumentValue(this.Engine, fractionDigitsArg, 0); // Check the parameter is within range. if (fractionDigits < 0 || fractionDigits > 20) { throw new JavaScriptException(this.Engine, "RangeError", "toFixed() argument must be between 0 and 20."); } // NumberFormatter does the hard work. return(NumberFormatter.ToString(this.m_value, 10, NumberFormatter.Style.Fixed, fractionDigits)); }
public void Time([DefaultParameterValue("")] object nameArg) { var name = JurassicHelper.GetTypedArgumentValue(this.Engine, nameArg, "") ?? string.Empty; if (this.m_timers == null) { this.m_timers = new Dictionary <string, Stopwatch>(); } if (this.m_timers.ContainsKey(name)) { return; } this.m_timers.Add(name, Stopwatch.StartNew()); }
public TermsFilterInstance CreateTermsFilter(object fieldName, object text) { var fieldNameValue = JurassicHelper.GetTypedArgumentValue(Engine, fieldName, String.Empty); var textValue = JurassicHelper.GetTypedArgumentValue(Engine, text, String.Empty); var termsFilter = new TermsFilter(); if (fieldNameValue.IsNullOrWhiteSpace() == false && textValue.IsNullOrWhiteSpace() == false) { termsFilter.Terms.Add(new Term { FieldName = fieldNameValue, Value = textValue }); } return(new TermsFilterInstance(Engine.Object.InstancePrototype, termsFilter)); }
public object GetValue(int row, int column) { var value = m_excelWorksheet.GetValue(row, column); if (value is int || value is string || value is double || value is bool) { return(value); } if (value is DateTime) { return(JurassicHelper.ToDateInstance(this.Engine, (DateTime)value)); } return(m_excelWorksheet.GetValue <string>(row, column)); }
public static double ParseInt(ScriptEngine engine, string input, [DefaultParameterValue(0.0)] object radixArg) { var radix = JurassicHelper.GetTypedArgumentValue(engine, radixArg, 0.0); // Check for a valid radix. // Note: this is the only function that uses TypeConverter.ToInt32() for parameter // conversion (as opposed to the normal method which is TypeConverter.ToInteger() so // the radix parameter must be converted to an integer in code. int radix2 = TypeConverter.ToInt32(radix); if (radix2 < 0 || radix2 == 1 || radix2 > 36) { return(double.NaN); } return(NumberParser.ParseInt(input, radix2, engine.CompatibilityMode == CompatibilityMode.ECMAScript3)); }
public void TimeEnd([DefaultParameterValue("")] object nameArg) { var name = JurassicHelper.GetTypedArgumentValue(this.Engine, nameArg, "") ?? string.Empty; if (this.m_timers == null || this.m_timers.ContainsKey(name) == false) { return; } var stopwatch = this.m_timers[name]; Log(FirebugConsoleMessageStyle.Regular, string.IsNullOrEmpty(name) ? string.Format("{0}ms", stopwatch.ElapsedMilliseconds) : string.Format("{0}: {1}ms", name, stopwatch.ElapsedMilliseconds)); this.m_timers.Remove(name); }
public static ObjectInstance Create(ScriptEngine engine, object prototype, [DefaultParameterValue(null)] object propertiesArg) { var properties = JurassicHelper.GetTypedArgumentValue <ObjectInstance>(engine, propertiesArg, null); if ((prototype is ObjectInstance) == false && prototype != Null.Value) { throw new JavaScriptException(engine, "TypeError", "object prototype must be an object or null"); } ObjectInstance result = prototype == Null.Value ? ObjectInstance.CreateRootObject(engine) : ObjectInstance.CreateRawObject((ObjectInstance)prototype); if (properties != null) { DefineProperties(result, properties); } return(result); }
protected override ObjectSettings Unwrap(ObjectInstance objectSettings) { if (objectSettings == null) { return(null); } var os = objectSettings as ObjectSettingsInstance; if (os != null) { return(os.ObjectSettings); } var os2 = JurassicHelper.Coerce <ObjectSettingsInstance>(Engine, objectSettings); return(os2.ObjectSettings); }
public static ArrayInstance Split(ScriptEngine engine, string thisObject, object separator, [DefaultParameterValue(4294967295.0)] object limitArg) { var limit = JurassicHelper.GetTypedArgumentValue(engine, limitArg, 4294967295.0); // Limit defaults to unlimited. Note the ToUint32() conversion. uint limit2 = uint.MaxValue; if (TypeUtilities.IsUndefined(limit) == false) { limit2 = TypeConverter.ToUint32(limit); } // Call separate methods, depending on whether the separator is a regular expression. if (separator is RegExpInstance) { return(Split(thisObject, (RegExpInstance)separator, limit2)); } return(Split(engine, thisObject, TypeConverter.ToString(separator), limit2)); }
protected override IBaristaCookie Unwrap(ObjectInstance cookie) { if (cookie == null) { return(null); } //If c is cookie, that's good for me. var c = cookie as BaristaCookieInstance; if (c != null) { return(c.BaristaCookie); } var os2 = JurassicHelper.Coerce <BaristaCookieInstance>(Engine, cookie); return(os2.BaristaCookie); }
public string PutIndex(object name, object indexDefinition, object overwrite) { if (name == null || name == Undefined.Value || name == Null.Value) { throw new JavaScriptException(this.Engine, "Error", "The first argument must contain the index name."); } if (indexDefinition == null || indexDefinition == Undefined.Value || indexDefinition == Null.Value) { throw new JavaScriptException(this.Engine, "Error", "The second argument must contain the index definition."); } var strName = TypeConverter.ToString(name); RavenDB.Abstractions.Indexing.IndexDefinition objIndexDefinition; if (indexDefinition is IndexDefinitionInstance) { objIndexDefinition = (indexDefinition as IndexDefinitionInstance).IndexDefinition; } else if (indexDefinition is ObjectInstance) { objIndexDefinition = JurassicHelper.Coerce <IndexDefinitionInstance>(this.Engine, indexDefinition).IndexDefinition; } else { throw new JavaScriptException(this.Engine, "Error", "The second argument must contain either an instance of IndexDefinition or a object that can be converted"); } string result; if (overwrite != null && overwrite != Null.Value && overwrite != Undefined.Value) { result = m_databaseCommands.PutIndex(strName, objIndexDefinition, TypeConverter.ToBoolean(overwrite)); } else { result = m_databaseCommands.PutIndex(strName, objIndexDefinition); } return(result); }