private HelixWatch3DNodeViewModel(Dynamo.Nodes.Watch3D node, Watch3DViewModelStartupParams parameters): base(parameters) { watchNode = node; IsResizable = true; RegisterPortEventHandlers(node); watchNode.Serialized += SerializeCamera; watchNode.Deserialized += watchNode_Deserialized; }
public void Serialize() { var Serializer = new JsonSerializer(); dynamic Object = new { A = 5, B = "ASDF" }; Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object)); Object = new TestObject { A = 5, B = "ASDF" }; Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object)); Object = new ExpandoObject(); Object.A = 5; Object.B = "ASDF"; Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object)); Object = new Dynamo(); Object.A = 5; Object.B = "ASDF"; Assert.Equal("{\"A\":5,\"B\":\"ASDF\"}", Serializer.Serialize(Object.GetType(), Object)); }
public void SetupCustomUIElements(Dynamo.Controls.dynNodeView nodeUI) { var fileName = "DeprecatedNode.png"; if (this.NodeNature == Nature.Unresolved) fileName = "MissingNode.png"; var src = @"/DSCoreNodesUI;component/Resources/" + fileName; Image dummyNodeImage = new Image() { Stretch = System.Windows.Media.Stretch.None, Source = new BitmapImage(new Uri(src, UriKind.Relative)) }; nodeUI.inputGrid.Children.Add(dummyNodeImage); this.Warning(GetDescription()); }
/// <summary> /// Gets the page count for the mapping specified /// </summary> /// <param name="Version">API version number</param> /// <param name="Mapping">Mapping name</param> /// <param name="PageSize">Size of the page.</param> /// <returns>The resulting items</returns> public Dynamo PageCount(int Version, string Mapping, int PageSize) { try { IDictionary<string, IAPIMapping> TempMappings = Mappings.GetValue(Version).Mappings; if (!TempMappings.ContainsKey(Mapping)) return new Dynamo(new { PageCount = 0 }); var ReturnValue = new Dynamo(new { PageCount = TempMappings[Mapping].PageCount(Mappings.GetValue(Version), PageSize) }); return ReturnValue; } catch { return new Dynamo(new { PageCount = 0 }); } }
/// <summary> /// Gets the property as a parameter (for classes, this will return the ID of the property) /// </summary> /// <param name="Object">Object to get the parameter from</param> /// <returns>The parameter version of the property</returns> public override object GetParameter(Dynamo Object) { return(null); }
/// <summary> /// Runs the specified service /// </summary> /// <param name="Version">API version number</param> /// <param name="Mapping">Mapping name</param> /// <param name="Value">The value.</param> /// <returns>The result from running the service</returns> public Dynamo CallService(int Version, string Mapping, Dynamo Value) { try { if (!WorkflowManager.CreateWorkflow<WorkflowInfo>(Mapping + "_PreService_" + Version).Start(new WorkflowInfo(Mapping, WorkflowType.PreService, Version, Value)).Continue) return Error("Error running service"); IDictionary<string, IService> TempMappings = Services.GetValue(Version).Services; if (!TempMappings.ContainsKey(Mapping)) return Error("Error getting item"); var ReturnValue = TempMappings[Mapping].Process(Value); if (!WorkflowManager.CreateWorkflow<WorkflowInfo>(Mapping + "_PostService_" + Version).Start(new WorkflowInfo(Mapping, WorkflowType.PostService, Version, ReturnValue)).Continue) return Error("Error running service"); return ReturnValue; } catch { return Error("Error running service"); } }
private ObjectType GetCached <ObjectType>(ref Dynamo ReturnValue, string KeyName) where ObjectType : class { Contract.Requires(this.Cache != null); ReturnValue = (Dynamo)Cache[KeyName]; return(ConvertValue <ObjectType>(ReturnValue)); }
/// <summary> /// Gets the property as a parameter (for classes, this will return the ID of the property) /// </summary> /// <param name="Object">Object to get the parameter from</param> /// <returns>The parameter version of the property</returns> public override object GetParameter(Dynamo Object) { return ForeignMapping.IDProperties.FirstOrDefault().GetValue(GetValue(Object)); }
async Task <APIGatewayProxyResponse> CreatePostResponse(JObject input, ILambdaContext context) { JObject preference = new Preference().preference; int statusCode = (input != null) ? (int)HttpStatusCode.OK : (int)HttpStatusCode.InternalServerError; Document writeDocument = new Document(); string sn = input["sn"].ToString(); string stage = String.Format("{0}-{1}-{2}", input["code"], input["type"], "simulation"); writeDocument["sn"] = sn; writeDocument["code"] = String.Format("{0}-{1}", input["code"], input["type"]); writeDocument["status"] = @"start"; Dynamo.writeDynamoTable(tableRegion: preference["Dynamo"]["Simulation"]["Region"].ToString(), tableName: preference["Dynamo"]["Simulation"]["Name"].ToString(), writeDocument: writeDocument).Wait(); await ProgressWriter.writer(sn : sn, stage : stage, status : "start"); List <SimulationMeta> metas = JArray.Parse(input["meta"].ToString()).Select(input_meta => new SimulationMeta(input_meta as JObject)).ToList(); context.Logger.LogLine("number of meta data: " + metas.Count); if (!input.ContainsKey("size")) { input["size"] = 1000000; } string body = ""; context.Logger.LogLine("Simulation start"); float[] results = Simulation.RunSimulation(metas, Convert.ToInt32(input["size"])); SimulationResult simulationResult = new SimulationResult(results); writeStreamFromStreamToS3(bucketRegion: preference["S3"]["Simulation"]["Region"].ToString(), keyName: String.Format("{0}-{1}-{2}.sim", input["sn"], input["code"], input["type"]), bucketName: preference["S3"]["Simulation"]["Name"].ToString(), stream: simulationResult.ToStream()).Wait(); writeDocument["status"] = @"end"; Dynamo.writeDynamoTable(tableRegion: preference["Dynamo"]["Simulation"]["Region"].ToString(), tableName: preference["Dynamo"]["Simulation"]["Name"].ToString(), writeDocument: writeDocument).Wait(); await ProgressWriter.writer(sn : sn, stage : stage, status : "end"); var response = new APIGatewayProxyResponse { StatusCode = statusCode, Body = body, Headers = new Dictionary <string, string> { { "Content-Type", "application/json" }, { "Access-Control-Allow-Origin", "*" } } }; return(response); }
private static void CopyOrAdd(List <Dynamo> ReturnValue, IProperty IDProperty, Dynamo Item) { Contract.Requires <ArgumentNullException>(IDProperty != null); if (Item == null) { return; } if (ReturnValue == null) { ReturnValue = new List <Dynamo>(); } var IDValue = IDProperty.GetValue(Item); var Value = ReturnValue.FirstOrDefault(x => IDProperty.GetValue(x).Equals(IDValue)); if (Value == null) { ReturnValue.Add(Item); } else { Item.CopyTo(Value); } }
public void PublishCustomNode(Dynamo.Nodes.Function m) { CustomNodeInfo currentFunInfo; if (DynamoViewModel.Model.CustomNodeManager.TryGetNodeInfo( m.Definition.FunctionId, out currentFunInfo)) { var termsOfUseCheck = new TermsOfUseHelper(new TermsOfUseHelperParams { PackageManagerClient = Model, AuthenticationManager = AuthenticationManager, ResourceProvider = DynamoViewModel.BrandingResourceProvider, AcceptanceCallback = () => ShowNodePublishInfo(new[] { Tuple.Create(currentFunInfo, m.Definition) }) }); termsOfUseCheck.Execute(); } }
/// <summary> /// Initializes a new instance of the <see cref="QueryResults"/> class. /// </summary> /// <param name="value">The value.</param> /// <param name="objectType">Type of the object.</param> /// <exception cref="ArgumentNullException">query</exception> public CachedResult(Dynamo value, Type objectType) { Value = value ?? throw new ArgumentNullException(nameof(value)); ObjectType = objectType; }
public SymTable(Dynamo _dynamo) { dynamo = _dynamo; }
/// <summary> /// Gets the property as a parameter (for classes, this will return the ID of the property) /// </summary> /// <param name="Object">Object to get the parameter from</param> /// <returns>The parameter version of the property</returns> public override object GetParameter(Dynamo Object) { return(GetValue(Object)); }
public static HelixWatch3DNodeViewModel Start(Dynamo.Nodes.Watch3D node, Watch3DViewModelStartupParams parameters) { var vm = new HelixWatch3DNodeViewModel(node, parameters); vm.OnStartup(); return vm; }
public void TestCreateDynamo() { var item = new Dynamo(); Assert.IsNotNull(item); }
public Dynamo Process(Dynamo Value) { return(Value); }
private static IList<dynamic> GetValues(DbDataReader TempReader) { Contract.Requires<ArgumentNullException>(TempReader != null, "TempReader"); var ReturnValue = new List<dynamic>(); string[] FieldNames = new string[TempReader.FieldCount]; for (int x = 0; x < TempReader.FieldCount; ++x) { FieldNames[x] = TempReader.GetName(x); } while (TempReader.Read()) { var Value = new Dynamo(); for (int x = 0; x < TempReader.FieldCount; ++x) { Value.Add(FieldNames[x], TempReader[x]); } ReturnValue.Add(Value); } return ReturnValue; }
/// <summary> /// Gets the property's value from the object sent in /// </summary> /// <param name="Object">Object to get the value from</param> /// <returns>The value of the property</returns> public object GetValue(Dynamo Object) { return(Object[Name]); }
/// <summary> /// Gets the property as a parameter (for classes, this will return the ID of the property) /// </summary> /// <param name="Object">Object to get the parameter from</param> /// <returns>The parameter version of the property</returns> public abstract object GetParameter(Dynamo Object);
/// <summary> /// Gets all items of the mapped type /// </summary> /// <param name="Mappings">The mapping holder</param> /// <param name="PageSize">Size of the page.</param> /// <param name="Page">The page specified</param> /// <param name="OrderBy">The order by clause</param> /// <param name="EmbeddedProperties">Properties to embed</param> /// <returns>All items of the mapped type</returns> public IEnumerable <Dynamo> Paged(MappingHolder Mappings, int PageSize, int Page, string[] OrderBy, string[] EmbeddedProperties) { if (OrderBy == null) { OrderBy = new string[0]; } string OrderByClauseFinal = ""; string Splitter = ""; foreach (string OrderByClause in OrderBy) { string[] SplitValues = OrderByClause.Split(' '); if (SplitValues.Length > 0) { if (Properties.Where(x => x is IReference || x is IID).Any(x => string.Equals(x.Name, SplitValues[0], StringComparison.InvariantCulture))) { OrderByClauseFinal += Splitter + SplitValues[0]; if (SplitValues.Length > 1) { SplitValues[1] = SplitValues[1].Equals("DESC", StringComparison.InvariantCultureIgnoreCase) ? "DESC" : "ASC"; OrderByClauseFinal += " " + SplitValues[1]; } Splitter = ","; } } } IEnumerable <ClassType> Objects = PagedFunc(PageSize, Page, OrderByClauseFinal); if (Objects == null) { Objects = new List <ClassType>(); } var ReturnValue = new List <Dynamo>(); foreach (ClassType Object in Objects) { if (CanGetFunc(Object)) { var TempItem = new Dynamo(Object); Dynamo ReturnItem = TempItem.SubSet(Properties.Where(x => x is IReference || x is IID) .Select(x => x.Name) .ToArray()); string AbsoluteUri = HttpContext.Current != null?HttpContext.Current.Request.Url.AbsoluteUri.Left(HttpContext.Current.Request.Url.AbsoluteUri.IndexOf('?')) : ""; AbsoluteUri = AbsoluteUri.Check(""); if (!AbsoluteUri.EndsWith("/", StringComparison.Ordinal)) { AbsoluteUri += "/"; } AbsoluteUri += Properties.FirstOrDefault(x => x is IID).GetValue(Mappings, Object).ToString() + "/"; foreach (IAPIProperty Property in Properties.Where(x => x is IMap)) { ReturnItem[Property.Name] = EmbeddedProperties.Contains(Property.Name) ? (object)Property.GetValue(Mappings, TempItem) : (object)(AbsoluteUri + Property.Name); } ReturnValue.Add(ReturnItem); } } return(ReturnValue); }
public bool CanPublishCustomNode(Dynamo.Nodes.Function m) { return AuthenticationManager.HasAuthProvider && m != null; }
/// <summary> /// Executes the commands and returns the results /// </summary> /// <returns> /// The results of the batched commands /// </returns> public IList<IList<dynamic>> Execute() { var ReturnValue = new List<IList<dynamic>>(); if (Commands.Count == 0) { ReturnValue.Add(new List<dynamic>()); return ReturnValue; } using (DirectoryEntry Entry = new DirectoryEntry(Source.Server, Source.UserName, Source.Password, AuthenticationTypes.Secure)) { using (DirectorySearcher Searcher = new DirectorySearcher(Entry)) { Searcher.PageSize = 1000; foreach (Command Command in Commands) { Searcher.Filter = Command.SQLCommand; using (SearchResultCollection Results = Searcher.FindAll()) { var ReturnValues = new List<dynamic>(); foreach (SearchResult Result in Results) { var TempValue = new Dynamo(); foreach (PropertyValueCollection Property in Result.GetDirectoryEntry().Properties) { TempValue[Property.PropertyName] = Property.Value; ReturnValues.Add(TempValue); } } ReturnValue.Add(ReturnValues); } } } Entry.Close(); } for (int x = 0; x < Commands.Count(); ++x) { Commands[x].Finalize(ReturnValue[x]); } return ReturnValue; }