Example #1
0
    public async void SaveParameters()
    {
        if (Base.Action.CheckIfAllValuesValid(actionParameters))
        {
            List <IO.Swagger.Model.ActionParameter> parameters = new List <IO.Swagger.Model.ActionParameter>();
            foreach (IActionParameter actionParameter in actionParameters)
            {
                IO.Swagger.Model.ActionParameterMeta metadata = CurrentAction.Metadata.GetParamMetadata(actionParameter.GetName());
                IO.Swagger.Model.ActionParameter     ap       = new IO.Swagger.Model.ActionParameter(id: actionParameter.GetName(), value: JsonConvert.SerializeObject(actionParameter.GetValue()), type: metadata.Type);
                parameters.Add(ap);
            }
            bool success = await Base.GameManager.Instance.UpdateAction(CurrentAction.Data.Id, parameters);

            if (success)
            {
                Base.Notifications.Instance.ShowNotification("Parameters saved", "");
                SaveParametersBtn.SetInteractivity(false, "Parameters unchanged");
                parametersChanged = false;
                if (string.IsNullOrEmpty(GameManager.Instance.ExecutingAction))
                {
                    ExecuteActionBtn.SetInteractivity(true);
                }
            }
        }
    }
Example #2
0
        public ActionParameterMetadata(IO.Swagger.Model.ActionParameterMeta actionParameterMeta) : base(defaultValue: actionParameterMeta.DefaultValue, description: actionParameterMeta.Description, dynamicValue: actionParameterMeta.DynamicValue,
                                                                                                        dynamicValueParents: actionParameterMeta.DynamicValueParents, extra: actionParameterMeta.Extra, name: actionParameterMeta.Name, type: actionParameterMeta.Type)
        {
            if (Extra != null && Extra != "{}")  // TODO solve better than with test of brackets

            {
                switch (Type)
                {
                case "string_enum":
                    ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.StringEnumParameterExtra>(Extra);
                    break;

                case "integer_enum":
                    ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.IntegerEnumParameterExtra>(Extra);
                    break;

                case "integer":
                    ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.IntParameterExtra>(Extra);
                    break;

                case "double":
                    ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.DoubleParameterExtra>(Extra);
                    break;
                }
            }
        }
        public ActionParameter(IO.Swagger.Model.ActionParameterMeta actionParameterMetadata, Action action, object value)
        {
            ActionParameterMetadata = new ActionParameterMetadata(actionParameterMetadata);
            Id     = ActionParameterMetadata.Name;
            Type   = ActionParameterMetadata.Type;
            Action = action;

            switch (Type)
            {
            case "relative_pose":
                SetValue((IO.Swagger.Model.Pose)value);
                break;

            case "integer_enum":
            case "integer":
                SetValue((int)value);
                break;

            case "string_enum":
            case "pose":
            case "joints":
            case "string":
                SetValue((string)value);
                break;

            case "double":
                SetValue((double)value);
                break;
            }
        }
        /// <summary>
        /// Creates action parameter based on it's metadata, parent action and action paramater swagger model.
        /// </summary>
        /// <param name="actionParameterMetadata"></param>
        /// <param name="action"></param>
        /// <param name="value"></param>
        public ActionParameter(IO.Swagger.Model.ActionParameterMeta actionParameterMetadata, Action action, string value)
        {
            Debug.Assert(value != null);
            ActionParameterMetadata = new ActionParameterMetadata(actionParameterMetadata);
            Id     = ActionParameterMetadata.Name;
            Type   = ActionParameterMetadata.Type;
            Action = action;
            Value  = value;

            /* else {
             *  switch (Type) {
             *      case "relative_pose":
             *          //SetValue(Regex.Replace(new IO.Swagger.Model.Pose(orientation: new IO.Swagger.Model.Orientation(), position: new IO.Swagger.Model.Position()).ToJson(), @"\t|\n|\r", ""));
             *          SetValue(new IO.Swagger.Model.Pose(orientation: new IO.Swagger.Model.Orientation(), position: new IO.Swagger.Model.Position()));
             *          break;
             *      case "integer_enum":
             *          if (ActionParameterMetadata.DefaultValue != null)
             *              Value = ActionParameterMetadata.DefaultValue;
             *          else
             *              SetValue(((ARServer.Models.IntegerEnumParameterExtra) ActionParameterMetadata.ParameterExtra).AllowedValues[0].ToString());
             *          break;
             *      case "string_enum":
             *          if (ActionParameterMetadata.DefaultValue != null)
             *              Value = ActionParameterMetadata.DefaultValue;
             *          else
             *              SetValue(((ARServer.Models.StringEnumParameterExtra) ActionParameterMetadata.ParameterExtra).AllowedValues[0]);
             *          break;
             *      case "pose":
             *          List<string> poses = new List<string>(action.ActionPoint.GetPoses().Keys);
             *          if (poses.Count == 0) {
             *              SetValue("");
             *              //TODO: where to get valid ID?
             *          } else {
             *              SetValue(action.ActionPoint.ActionObject.Data.Id + "." + action.ActionPoint.Data.Id + "." + poses[0]);
             *          }
             *          break;
             *      case "joints":
             *          List<string> joints = new List<string>(action.ActionPoint.GetJoints().Keys);
             *          if (joints.Count == 0) {
             *              SetValue("");
             *              //TODO: where to get valid ID?
             *          } else {
             *              SetValue(action.ActionPoint.ActionObject.Data.Id + "." + action.ActionPoint.Data.Id + "." + joints[0]);
             *          }
             *          break;
             *      default:
             *          Value = ActionParameterMetadata.DefaultValue;
             *          break;
             *
             *  }
             * }*/
        }
Example #5
0
        public ActionParameterMetadata(IO.Swagger.Model.ActionParameterMeta actionParameterMeta) : base(actionParameterMeta.DefaultValue, actionParameterMeta.Description, actionParameterMeta.DynamicValue,
                                                                                                        actionParameterMeta.DynamicValueParents, actionParameterMeta.Extra, actionParameterMeta.Name, actionParameterMeta.Type)
        {
            switch (Type)
            {
            case "string_enum":
                ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.StringEnumParameterExtra>(Extra);
                break;

            case "integer_enum":
                ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.IntegerEnumParameterExtra>(Extra);
                break;

            case "integer":
                ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.IntParameterExtra>(Extra);
                break;

            case "double":
                ParameterExtra = JsonConvert.DeserializeObject <ARServer.Models.DoubleParameterExtra>(Extra);
                break;
            }
        }
Example #6
0
        public virtual void ActionUpdate(IO.Swagger.Model.Action action, bool updateConnections = false)
        {
            // Updates (or creates new) parameters of current action
            foreach (IO.Swagger.Model.ActionParameter projectActionParameter in action.Parameters)
            {
                try {
                    // If action parameter exist in action dictionary, then just update that parameter value (it's metadata will always be unchanged)
                    if (Parameters.TryGetValue(projectActionParameter.Id, out ActionParameter actionParameter))
                    {
                        actionParameter.UpdateActionParameter(projectActionParameter);
                    }
                    // Otherwise create a new action parameter, load metadata for it and add it to the dictionary of action
                    else
                    {
                        // Loads metadata of specified action parameter - projectActionParameter. Action.Metadata is created when creating Action.
                        IO.Swagger.Model.ActionParameterMeta actionParameterMetadata = Metadata.GetParamMetadata(projectActionParameter.Id);

                        actionParameter = new ActionParameter(actionParameterMetadata, this, projectActionParameter.Value);
                        Parameters.Add(actionParameter.Id, actionParameter);
                    }
                } catch (ItemNotFoundException ex) {
                    Debug.LogError(ex);
                }
            }
            if (updateConnections)
            {
                string actionOutput = "end";
                if (action.Outputs.Count > 0)
                {
                    actionOutput = action.Outputs[0].Default;
                }

                if (actionOutput != Output.Data.Default)
                {
                    //at the moment, each action has exactly one input and one output
                    Action refAction = null;
                    if (actionOutput != "start" && actionOutput != "end")
                    {
                        refAction = Scene.Instance.GetAction(actionOutput);
                    }

                    if (Output.Connection != null)
                    {
                        ConnectionManagerArcoro.Instance.Connections.Remove(Output.Connection);
                        Destroy(Output.Connection.gameObject);
                    }

                    // Create new connection only if connected action exists (it is not start nor end)
                    if (refAction != null)
                    {
                        // Create new one
                        PuckInput input = refAction.Input;

                        GameObject c = Instantiate(Scene.Instance.ConnectionPrefab);
                        c.transform.SetParent(ConnectionManager.instance.transform);
                        Connection newConnection = c.GetComponent <Connection>();
                        // We are always connecting output to input.
                        newConnection.target[0] = Output.gameObject.GetComponent <RectTransform>();
                        newConnection.target[1] = input.gameObject.GetComponent <RectTransform>();

                        input.Connection    = newConnection;
                        Output.Connection   = newConnection;
                        input.Data.Default  = Data.Id;
                        Output.Data.Default = refAction.Data.Id;
                        ConnectionManagerArcoro.Instance.Connections.Add(newConnection);
                    }
                    else
                    {
                        refAction = Scene.Instance.GetAction(Output.Data.Default);
                        refAction.Input.InitData();
                        Output.InitData();
                    }
                }
            }
        }