/// <summary> /// Returns the value of one of the text attributes from the input parameter of the given name. /// </summary> public string GetInputParameterText(EntityEnum entity, InputParameter inputParameter) { if (inputParameter == null) { return(string.Empty); } switch (entity) { case EntityEnum.Given: return((inputParameter.Given == null) ? string.Empty : inputParameter.Given); case EntityEnum.Name: return((inputParameter.Name == null) ? string.Empty : inputParameter.Name); case EntityEnum.Value: return((inputParameter.Text == null) ? string.Empty : inputParameter.Text); case EntityEnum.Condition: return((inputParameter.Condition == null) ? string.Empty : inputParameter.Condition); default: return(string.Empty); } }
/// <summary> /// Sets the value of one of the text attributes in the input parameter of the given name. /// </summary> public void SetInputParameterText(EntityEnum entity, string parameterName, string text) { InputParameter inputParameter = GetInputParameter(parameterName); if (inputParameter == null) { return; } switch (entity) { case EntityEnum.Given: inputParameter.Given = text; break; case EntityEnum.Name: inputParameter.Name = text; break; case EntityEnum.Value: inputParameter.Text = text; break; case EntityEnum.Condition: inputParameter.Condition = text; inputParameter.ParseConditions(); break; default: break; } }
public User GetUserDetails(string userName, string password) { User user = null; try { StoredProcedure coreCustomerProcedure = new StoredProcedure("usp_GetUserDetails"); coreCustomerProcedure.WithParameters(InputParameter.Named("UserName").WithValue(userName)); coreCustomerProcedure.WithParameters(InputParameter.Named("Password").WithValue(password)); using (IDataReader datareader = DataConnectionHelper.GetConnectionManager().ExecuteReader(coreCustomerProcedure)) { while (datareader.Read()) { user = new User(); user.UserId = datareader.GetInt64OrDefault("UserID"); user.UserName = datareader.GetStringOrDefault("Name"); user.Email = datareader.GetStringOrDefault("Email"); user.RoleId = datareader.GetInt64OrDefault("RoleId"); } } } catch (Exception ex) { } return(user); }
private object CallMethod(object instance, MethodInfo method, IList <InputParameter> inputParameters) { ParameterInfo[] methodParameters = method.GetParameters(); if (inputParameters.Count > methodParameters.Length) { throw new InvalidOperationException($"Mismatch parameters count. Input parameters count: {inputParameters.Count}. Method parameters count: {methodParameters.Length}. MethodCallTemplate: {MethodCallTemplate}"); } ParameterInfo[] requiredParams = methodParameters.Where(p => !p.IsOptional).ToArray(); if (inputParameters.Count < requiredParams.Length) { throw new InvalidOperationException($"Mismatch parameters count. Input parameters count: {inputParameters.Count}. Method required parameters count: {requiredParams.Length}. MethodCallTemplate: {MethodCallTemplate}"); } object[] callParams = methodParameters.Select(p => p.HasDefaultValue() ? p.DefaultValue : null).ToArray(); for (int i = 0; i < inputParameters.Count; i++) { InputParameter param = inputParameters[i]; if (param.Type != null || param.Value == null) { callParams[i] = param.Value; } else { Type paramType = methodParameters[i].ParameterType; callParams[i] = Convert.ChangeType(param.Value, paramType); } } return(method.Invoke(instance, callParams)); }
public void Ctor_WithUnknownType() { var target = new InputParameter <Tuple <string> >("@p1"); //Assert target.DbType.Should().Be(DbType.Object); }
public Parameter Map(InputParameter param) { var mapping = Register(param.Type); return(new Parameter { type = mapping.Type, format = mapping.Format, name = param.Name }); }
public void Ctor_WithName() { var target = new InputParameter <int>("@p1"); //Assert target.Name.Should().Be("@p1"); target.DbType.Should().Be(DbType.Int32); }
public void Reschedule(InputParameter param) { var triggerKey = new TriggerKey(param.Trigger, param.Group); var oTrigger = Scheduler.GetTrigger(triggerKey); var nTrigger = oTrigger.GetTriggerBuilder().WithCronSchedule(param.CronExpression).Build(); Scheduler.RescheduleJob(triggerKey, nTrigger); }
public void Named_WithValidValue() { var expected = "@s1"; var target = InputParameter.Named(expected).WithValue(""); //Assert target.Name.Should().Be(expected); }
public void WithValue_IsValid() { var expected = 40; var target = InputParameter.Named("@in1").WithValue(expected); //Assert target.Value.Should().Be(expected); }
/// <summary> /// Refreshes the data fields for the specific input parameter. /// </summary> private void RefreshParameterData(string parameterName) { InputParameter inputParameter = model.GetInputParameter(parameterName); richTextBox7.Text = model.GetInputParameterText(EntityEnum.Given, inputParameter); textBox1.Text = model.GetInputParameterText(EntityEnum.Name, inputParameter); textBox2.Text = model.GetInputParameterText(EntityEnum.Value, inputParameter); richTextBox4.Text = model.GetInputParameterText(EntityEnum.Condition, inputParameter); }
public ActionResult InputParameter(InputParameter testSpecification) { ViewBag.Message = "Your contact page."; //Save Specification InputParameter input = new InputParameter(testSpecification.Name, testSpecification.Text); //Redirect return(Redirect("/")); }
public List<TaskHead> GetTaskList(InputParameter param) { List<TaskHead> taskList = new List<TaskHead>(); param.CompanyId = userService.GetLoggdInUser().CompanyId; param.BranchId = userService.GetLoggdInUser().BranchId; List<ProTask> proTaskList = new List<ProTask>(); proTaskList = taskRepositry.GetTasks(userService.GetLoggdInUser().CompanyId, userService.GetLoggdInUser().BranchId) .Where(ts => ts.DateOfStart.Value.Date < DateTime.Now.Date).ToList(); }
/// <summary> /// Edits the value of a parameter /// </summary> /// <param name="parameter"></param> /// <param name="value"></param> virtual public void EditItem(String parameter, object value) { AppAssert.AssertNotNull(parameter, "parameter"); AppAssert.Assert(this.parameterList.Contains(parameter), "Parameter List does not contain this parameter", parameter); AppAssert.AssertNotNull(value, "value"); InputParameter inputParameter = PropertyBagDictionary.Instance.GetProperty <InputParameter>(parameter); inputParameter.SetInputValue(value); }
public Dashboard GetDashboardTaskCount(int dateType) { InputParameter param = new InputParameter { CompanyId = userService.GetLoggdInUser().CompanyId, BranchId = userService.GetLoggdInUser().BranchId, DateType = dateType }; var dashboardData = taskRepositry.GetDashboardTaskCount(param); return (dashboardData != null) ? dashboardData : new Dashboard(); }
public void SetsDbNullWhenStringValueIsNull() { var toTest = new InputParameter("Foo", default(string), DbType.String); var res = toTest.CreateDbDataParameter(CreateCommand()); res.DbType.Should().Be(DbType.String, "it was passed in the constructor"); res.ParameterName.Should().Be("Foo", "it was passed in the constructor"); res.Value.Should().Be(DBNull.Value, "DBNull.Value should be used for null values"); res.Direction.Should().Be(ParameterDirection.Input, "it is an input parameter"); }
public void DbTypeInferredWhenNotSet() { var toTest = new InputParameter("Foo", 123M); var res = toTest.CreateDbDataParameter(CreateCommand()); res.DbType.Should().Be(DbType.Decimal, "it should have been inferred"); res.ParameterName.Should().Be("Foo", "it was passed in the constructor"); res.Value.Should().Be(123M, "it was passed in the constructor"); res.Direction.Should().Be(ParameterDirection.Input, "it is an input parameter"); }
/// <summary> /// This function redirect to the search function in the practitioner controller to perform search query in FHIR server passing in the practitionerId as the input parameter /// </summary> /// <param name="patientId"></param> /// <returns></returns> public async Task Search(InputParameter patientId) { SearchInProgress = true; NotifyStateChanged(); Dashboard.FetchPatientList( await _http.GetFromJsonAsync <Dictionary <string, Patient> >($"/api/practitioner/{patientId.Value}")); Dashboard.ClearMonitor(); SearchInProgress = false; NotifyStateChanged(); }
public List <Model.DtOrderModel> GetDeliveryListBySP(InputParameter param) { List <DtOrderModel> deliveryList = new List <DtOrderModel>(); DataSet dsDeliveryData = GetData($"exec sp_phar_delivery_list {param.CompanyId},{param.BranchId},{param.Customer},'{param.FromDate}','{param.ToDate}',{param.DeliveryStatusType},'{param.SearchValue}',{param.PageNo},{param.PageSize},'{param.SortColumn}','{param.SortOrder}'", "Delivery"); if (dsDeliveryData != null && dsDeliveryData.Tables.Count > 0) { deliveryList = dsDeliveryData.Tables[0].ToList <DtOrderModel>(); } return(deliveryList); }
public void SetsConstructorValuesOnParameter() { var toTest = new InputParameter("Foo", 123, DbType.Int32); var res = toTest.CreateDbDataParameter(CreateCommand()); res.DbType.Should().Be(DbType.Int32, "it was passed in the constructor"); res.ParameterName.Should().Be("Foo", "it was passed in the constructor"); res.Value.Should().Be(123, "it was passed in the constructor"); res.Direction.Should().Be(ParameterDirection.Input, "it is an input parameter"); }
/// <summary> /// This function set parameter as a new interval setting for the timer /// </summary> /// <param name="timeInput"></param> /// <returns></returns> public void SetTime(InputParameter timeInput) { try { t.Interval = 1000 * 60 * int.Parse(timeInput.Value); } catch (InvalidCastException e) { Console.WriteLine("Value must be an integer"); throw; } }
public Dashboard GetDashboardTaskCount(string startDate, string endDate) { InputParameter param = new InputParameter { CompanyId = userService.GetLoggdInUser().CompanyId, BranchId = userService.GetLoggdInUser().BranchId, FromDate = startDate, ToDate = endDate }; var dashboardData = taskRepositry.GetDashboardTaskCount(param); return (dashboardData != null) ? dashboardData : new Dashboard(); }
public static User GetUser(this ConnectionManager source, int id) { var cmd = new AdhocQuery("SELECT Id, Name FROM Users where Id = @id").WithParameters( InputParameter.Named("id").WithValue(id) ); return(source.ExecuteQueryWithResult(cmd, r => new User(r.GetInt32OrDefault("Id")) { Name = r.GetStringOrDefault("Name") })); }
public UnexplainedVarianceProportion( InputParameter input, OutputParameter output, AnalyticalExpression formula, WorkedPointsErrorValue error ) { this.Input = input; this.Output = output; this.ModelFormula = formula; this.WorkedPointsError = error; }
public List <Dashboard> GetDriveryWiseDeliveries() { InputParameter param = new InputParameter { CompanyId = userService.GetLoggdInUser().CompanyId, BranchId = userService.GetLoggdInUser().BranchId, UserId = (userService.GetLoggdInUser().Role.ToLower().Equals("driver")) ? userService.GetLoggdInUser().UserId : -1 }; List <Dashboard> driverWiseSummary = deliveryRepository.GetDriverWiseSummary(param); return((driverWiseSummary != null) ? driverWiseSummary : new List <Dashboard>()); }
/// <summary> /// Returns the parameter's equivalence class object from the working specification /// that has the given name (otherwise null). /// </summary> public EquivalenceClass GetEquivalenceClass(string parameterName, string equivalenceClassName) { InputParameter inputParameter = GetInputParameter(parameterName); if ((inputParameter == null) || (inputParameter.EquivalenceClasses == null) || !inputParameter.EquivalenceClasses.ContainsKey(equivalenceClassName)) { return(null); } return(inputParameter.EquivalenceClasses[equivalenceClassName]); }
/// <summary> /// Deletes the input parameter from the specification and returns true if successful. /// </summary> public bool DeleteInputParameter(string parameterName) { InputParameter inputParameter = GetInputParameter(parameterName); if (inputParameter == null) { return(false); } workingTestSpecification.InputParameters.Remove(parameterName); workingTestSpecification.SpecificationDependencies.DeleteInputParameterReferences(parameterName); return(true); }
public void CanMapSimpleNullableTypes(Type type, string expectedParamType, string expectedFormat = "") { var mapper = new TypeMapper(); var inputParam = new InputParameter { Type = type }; var param = mapper.Map(inputParam); Assert.AreEqual(expectedParamType, param.type); Assert.AreEqual(expectedFormat, param.format); Assert.IsEmpty(mapper.Models); }
public IActionResult GetTaskList(string startDate, string endDate, int taskStatusType) { List <TaskHead> taskList = new List <TaskHead>(); InputParameter param = new InputParameter { FromDate = startDate, ToDate = endDate, TaskStatusType = taskStatusType }; taskList = taskService.GetTaskList(param); return(PartialView("TaskListPartial", taskList)); }
/// <summary> /// Logs all inputs to the log file /// </summary> public void LogInputs() { InputParameter inputParameter = null; foreach (String parameter in parameterList) { inputParameter = this.FindItem(parameter); if (inputParameter.Valid && inputParameter.CanLogToFile) { Trc.Log(Microsoft.VirtualManager.SetupFramework.LogLevel.Always, parameter); Trc.Log(Microsoft.VirtualManager.SetupFramework.LogLevel.Always, inputParameter.InputValue.ToString()); } } }
/// <summary> /// Implements the constructor: InputParameter() /// Direct superclasses: global::MetaDslx.Soal.NamedElement, global::MetaDslx.Soal.TypedElement, global::MetaDslx.Soal.AnnotatedElement /// All superclasses: global::MetaDslx.Soal.NamedElement, global::MetaDslx.Soal.TypedElement, global::MetaDslx.Soal.AnnotatedElement /// </summary> public virtual void InputParameter(InputParameter @this) { this.NamedElement(@this); this.TypedElement(@this); this.AnnotatedElement(@this); }