public bool PostFunctionDetails(FunctionDetails r) { try { Function_Details fs = new Function_Details(); fs.Function_Category_ID = r.Function_Category_ID; fs.Owner_ID = r.Owner_ID; fs.Function_Date = r.Function_Date; fs.Function_Details1 = r.Function_Details; fs.Function_Time = r.Function_Time; fs.Function_Duration = r.Function_Duration; fs.Function_Status = r.Function_Status; es.Function_Details.Add(fs); var res = es.SaveChanges(); if (res > 0) { return(true); } else { return(false); } } catch (Exception ex) { throw ex; } }
public IEnumerable <FunctionDetails> GetFunctionDetails() { try { List <FunctionDetails> fn = new List <FunctionDetails>(); var res = es.Function_Details.ToList(); foreach (var r in res) { FunctionDetails fs = new FunctionDetails(); fs.Function_ID = r.Function_ID; fs.Function_Category_ID = r.Function_Category_ID; fs.Owner_ID = r.Owner_ID; fs.Function_Date = r.Function_Date; fs.Function_Details = r.Function_Details1; fs.Function_Time = r.Function_Time; fs.Function_Duration = r.Function_Duration; fs.Function_Status = r.Function_Status; fn.Add(fs); } return(fn); } catch (Exception ex) { throw ex; } }
public FunctionDetails GetFunctionDetails(int id) { try { var r = es.Function_Details.Where(x => x.Function_ID == id).SingleOrDefault(); FunctionDetails fs = new FunctionDetails(); if (r != null) { fs.Function_ID = r.Function_ID; fs.Function_Category_ID = r.Function_Category_ID; fs.Owner_ID = r.Owner_ID; fs.Function_Date = r.Function_Date; fs.Function_Details = r.Function_Details1; fs.Function_Time = r.Function_Time; fs.Function_Duration = r.Function_Duration; fs.Function_Status = r.Function_Status; } else { throw new Exception("Invalid Id"); } return(fs); } catch (Exception ex) { throw ex; } }
public string PutFunctionDetails(FunctionDetails r, int id) { try { var fs = (from f in es.Function_Details where f.Function_ID == id select f).SingleOrDefault(); if (r == null) { return("ID Invalid"); } else { fs.Function_Category_ID = r.Function_Category_ID; fs.Owner_ID = r.Owner_ID; fs.Function_Date = r.Function_Date; fs.Function_Details1 = r.Function_Details; fs.Function_Time = r.Function_Time; fs.Function_Duration = r.Function_Duration; fs.Function_Status = r.Function_Status; var res = es.SaveChanges(); if (res > 0) { return("Data Updated"); } } return("Error In Inserting the data"); } catch (Exception ex) { throw ex; } }
public override object Evaluate(UnityELEvaluator context) { FunctionDetails functionDetails = ResolveFunction(context); if (functionDetails.Function == null) { if (functionDetails.ResolutionFailedReason == null) { functionDetails.ResolutionFailedReason = $"Unable to resolve function: {functionDetails.Name} " + $"(host={functionDetails.Host})"; //, namespace={functionDetails.Namespace})"; } throw new NoSuchFunctionException(this, functionDetails.ResolutionFailedReason); } // Map parameters... MethodInfo function = functionDetails.Function; List <object> parameters = functionDetails.Parameters; ParameterInfo[] parameterInfos = function.GetParameters(); if (parameterInfos.Length > 0) { // If there is a different number of arguments, see if the last argument is a params // and then wrap up the required number of arguments in an array (coercing as needed) ParameterInfo lastParam = parameterInfos[parameterInfos.Length - 1]; if (lastParam.IsDefined(typeof(ParamArrayAttribute), false)) { int varargCount = parameters.Count - parameterInfos.Length + 1; Type elementType = lastParam.ParameterType.GetElementType(); Array varargs = Array.CreateInstance(elementType, varargCount); for (int i = 0; i < varargCount; ++i) { varargs.SetValue(TypeCoercer.CoerceToType(elementType, this, parameters[parameters.Count - varargCount + i]), i); } parameters[parameterInfos.Length - 1] = varargs; parameters.RemoveRange(parameterInfos.Length, parameters.Count - parameterInfos.Length); } // Coerce the parameters if needed for (int i = 0; i < parameters.Count; ++i) { parameters[i] = TypeCoercer.CoerceToType(parameterInfos[i].ParameterType, this, parameters[i]); } } return(function.Invoke(functionDetails.Host, parameters.ToArray())); }
public List <ServiceInfo> GetServiceContracts() { var list = new List <ServiceInfo>(); var serviceInfo = new ServiceInfo(); foreach (var hub in _hubmanager.GetHubs()) { Type hubType = hub.HubType; string moduleName = hubType.Namespace; string interfaceName = hubType.Name; serviceInfo.ModuleName = moduleName; serviceInfo.InterfaceName = interfaceName; Type clientType = TypeHelper.ClientType(hubType); string clientTypeName = clientType != null ? clientType.FullName : "any"; serviceInfo.ClientType = clientTypeName; // Server type and functions string serverType = hubType.Name + "Server"; string serverFullNamespace = hubType.FullName + "Server"; serviceInfo.ServerType = serverType; serviceInfo.ServerTypeFullNamespace = serverFullNamespace; foreach (var method in _hubmanager.GetHubMethods(hub.Name)) { var ps = method.Parameters.Select(x => x.Name + " : " + TypeHelper.GetTypeContractName(x.ParameterType)); var functionDetails = new FunctionDetails() { Name = _typeHelper.FirstCharLowered(method.Name), Arguments = "(" + string.Join(", ", ps) + ")", ReturnType = "JQueryPromise<" + TypeHelper.GetTypeContractName(method.ReturnType) + ">" }; serviceInfo.ServerFunctions.Add(functionDetails); } list.Add(serviceInfo); } return(list); }
public List <FunctionDetails> GetClientFunctions(Type hubType) { var list = new List <FunctionDetails>(); Type clientType = ClientType(hubType); if (clientType != null) { foreach (var method in clientType.GetMethods()) { var functionDetails = new FunctionDetails(); IEnumerable <string> ps = method.GetParameters().Select(x => x.Name + " : " + GetTypeContractName(x.ParameterType)); string functionName = FirstCharLowered(method.Name); string functionArgs = "(" + string.Join(", ", ps) + ")"; functionDetails.Name = functionName; functionDetails.Arguments = functionArgs; list.Add(functionDetails); } } return(list); }
/// <summary> /// Generate a function in the current session using the specified /// function details /// </summary> /// <param name="details">details of the function</param> private void UpdateFunctionFromXaml(FunctionDetails details) { // Bind the command into the caller's command table. Note that if // ~/ has been passed to this cmdlet, then the Set operation will also be logged // the verbose stream. This is desirable as it shows the generated function... string functionName = "function:\\script:" + details.Name; // This script block is defined as FullLanguage mode, since it contains // no text that can be injected by the user. ScriptBlock xamlFunctionDefinition = null; PSLanguageMode oldLanguageMode = this.SessionState.LanguageMode; try { this.SessionState.LanguageMode = PSLanguageMode.FullLanguage; xamlFunctionDefinition = ScriptBlock.Create(details.FunctionDefinition); } finally { this.SessionState.LanguageMode = oldLanguageMode; } WorkflowInfo workflow = new WorkflowInfo(details.Name, "", xamlFunctionDefinition, details.Xaml, null); SessionState.InvokeProvider.Item.Set(functionName, workflow); }
/// <summary> /// Load a workflow XAML file from the specified path and generate a PowerShell /// function from the file. The name of the generated function will be the basename /// of the XAML file. /// </summary> /// <param name="name">The name of workflow.</param> /// <param name="xaml">The xaml of workflow.</param> /// <param name="requiredAssemblies"></param> /// <param name="dependentWorkflows">Any workflows required by this workflow.</param> /// <param name="dependentAssemblyPath">Path to the dependent assembly.</param> /// <param name="resolvedPath">Resolved Path of the xaml</param> /// <param name="sourceLanguageMode">Language mode of source in which workflow should run</param> private static FunctionDetails GenerateFunctionFromXaml( string name, string xaml, Dictionary<string, string> requiredAssemblies, string[] dependentWorkflows, string dependentAssemblyPath, string resolvedPath, PSLanguageMode sourceLanguageMode) { if (name == null) { ArgumentNullException argNullException = new ArgumentNullException("name"); Tracer.TraceException(argNullException); throw argNullException; } string modulePath = System.IO.Path.GetDirectoryName(resolvedPath); string functionDefinition = CreateFunctionFromXaml( name, xaml, requiredAssemblies, dependentWorkflows, dependentAssemblyPath, null, modulePath, false, "[CmdletBinding()]", null, /* scriptContent */ null, /* fullScript */ null, /* rootWorkflowName */ sourceLanguageMode, null); FunctionDetails details = new FunctionDetails {Name = name, FunctionDefinition = functionDefinition, Xaml = xaml}; return details; }
public bool Exists(UnityELEvaluator context) { FunctionDetails functionDetails = ResolveFunction(context); return(functionDetails.Function != null); }
private FunctionDetails ResolveFunction(UnityELEvaluator context) { FunctionDetails functionDetails = new FunctionDetails(); // See if there is a host object, otherwise we're looking for a static function on the evaluator if (FunctionName is PropertyAccessToken) { PropertyAccessToken propertyAccess = (PropertyAccessToken)FunctionName; functionDetails.Host = propertyAccess.Host.Evaluate(context); if (functionDetails.Host == null) { return(null); } functionDetails.Name = propertyAccess.Property.Value; } else if (FunctionName is IdentifierToken) { IdentifierToken identifier = (IdentifierToken)FunctionName; functionDetails.Host = null; functionDetails.Name = identifier.Value; } // Resolve arguments (if any) functionDetails.Parameters = new List <object>(); List <System.Type> types = new List <System.Type>(); int argIndex = 0; foreach (TokenImpl childToken in Children) { object value = null; if (childToken is ArgumentGroupToken) { value = ((ArgumentGroupToken)childToken).EvaluateForArgument(context, functionDetails.Name, argIndex); } else { value = childToken.Evaluate(context); } functionDetails.Parameters.Add(value); if (value != null) { types.Add(value.GetType()); } else { types.Add(null); } ++argIndex; } if (functionDetails.Host != null) { if (context.MemberFunctionResolver == null) { functionDetails.ResolutionFailedReason = $"Cannot resolve a member function as no MemberFunctionResolver has been configured on the context"; } else { functionDetails.Function = context.MemberFunctionResolver.ResolveFunction(functionDetails.Host.GetType(), functionDetails.Name, types.ToArray()); } /*} else if (functionDetails.Namespace != null) { * if (!context.FunctionResolvers.ContainsKey(functionDetails.Namespace)) { * functionDetails.ResolutionFailedReason = $"Unknown function namespace: {functionDetails.Namespace}"; * } else { * functionDetails.Function = context.FunctionResolvers[functionDetails.Namespace].ResolveFunction(functionDetails.Name, types.ToArray()); * }*/ } else { if (context.DefaultFunctionResolver == null) { functionDetails.ResolutionFailedReason = $"No function namespace was supplied and no default function resolver was setup"; } else { functionDetails.Function = context.DefaultFunctionResolver.ResolveFunction(functionDetails.Name, types.ToArray()); } } return(functionDetails); }
public bool Post(FunctionDetails fs) { return(fn.PostFunctionDetails(fs)); }
public string Put(int id, FunctionDetails fs) { return(fn.PutFunctionDetails(fs, id)); }
public bool Post([FromBody] FunctionDetails fs) { return(fn.PostFunctionDetails(fs)); }