private async Task <bool> SetUpMonRNorSvcFreq(ServiceEntity item, ServiceInput input, string mode) { int svcFreq = 0; int svcGroup = await GetSvcGroup(item.Button); CultureInfo myCI = new CultureInfo("en-US"); CalendarWeekRule myCWR = myCI.DateTimeFormat.CalendarWeekRule; Calendar myCal = myCI.Calendar; switch (mode) { case ServiceFrequency.EveryOtherDay: svcFreq = input.Today.DayOfYear % 2; break; case ServiceFrequency.BiWeekly: svcFreq = myCal.GetWeekOfYear(DateTime.Now, myCWR, input.Today.DayOfWeek) % 2; break; case ServiceFrequency.Monthly: svcFreq = myCal.GetWeekOfYear(DateTime.Now, myCWR, input.Today.DayOfWeek) % 4; break; default: break; } if (svcGroup != svcFreq) { item.MonRN = 1000; return(true); //breaks one iteration (in the loop) } item.SvcFreq += $"-{svcFreq}"; return(false); }
public async Task Execute(Guid serviceId, ServiceInput input) { var service = await ServiceRepository.GetAsync(serviceId); service.Name = input.Name; service.Cost = (int)input.Cost; }
public async Task UpdateService( [FromServices] UpdateServiceCommand command, [FromBody] ServiceInput input, [FromRoute] Guid serviceId ) { await command.Execute(serviceId, input); }
public void SelectService(string serviceid, string objectId, string message) { var input = new ServiceInput() { ServiceId = serviceid, ObjectId = objectId }; var result = data.tableSelectService(input); Assert.Equal(result, message); }
public string tableSelectService(ServiceInput input) { string[] setServiceId = { "01", "02" }; string[] setObjectiveIdService01 = { "01", "02", "03", "04", "05" }; string[] setObjectiveIdService02 = { "06", "07" }; string[] setMethodIdObjective = { "01", "02" }; string[] setMethodIdObjectiveMethod01 = { "02" }; string[] setMethodIdObjectiveMethod02 = { "01", "02" }; if (string.IsNullOrEmpty(input.ServiceId)) { return("Error"); } else if (setServiceId.Any(input.ServiceId.Contains)) { if (input.ServiceId == "01") { if (string.IsNullOrEmpty(input.ObjectId)) { return("Error"); } else if (setObjectiveIdService01.Any(input.ObjectId.Contains)) { if (input.ObjectId == "01") { return("Success"); } else if (input.ObjectId == "02") { return("Success"); } return("Success"); } return("Error"); } else if (input.ServiceId == "02") { if (string.IsNullOrEmpty(input.ObjectId)) { return("Error"); } else if (setObjectiveIdService02.Any(input.ObjectId.Contains)) { return("Success"); } return("Error"); } return("Error"); } else { return("Error"); } }
public void ActionInputDatalistMapper_MapInputsToDatalist_Should_MapToScalar() { var serviceInputs = new List <IServiceInput>(); var serviceInput = new ServiceInput("[[a]]", ""); serviceInputs.Add(serviceInput); Assert.AreEqual("", serviceInputs[0].Value); _actionInputDatalistMapper.MapInputsToDatalist(serviceInputs); Assert.AreEqual("[[a]]", serviceInputs[0].Value); }
public void ServiceInput_Constructor_WhenCharInName_ShouldConstructorScalarMappedTo() { //------------Setup for test-------------------------- const string mappingFrom = "`mapFrom`"; const string variableMapTo = "[[mapTo]]"; //------------Execute Test--------------------------- var serviceOutputMapping = new ServiceInput(mappingFrom, variableMapTo); //------------Assert Results------------------------- Assert.IsNotNull(serviceOutputMapping); Assert.AreEqual(mappingFrom.Replace("`", ""), serviceOutputMapping.Name); Assert.AreEqual(variableMapTo, serviceOutputMapping.Value); }
public void ServiceInput_Constructor_EmptyValue_ShouldStillConsturct() { //------------Setup for test-------------------------- const string mappingFrom = "mapFrom"; //------------Execute Test--------------------------- var serviceOutputMapping = new ServiceInput(mappingFrom, ""); //------------Assert Results------------------------- Assert.IsNotNull(serviceOutputMapping); Assert.AreEqual("", serviceOutputMapping.Value); Assert.AreEqual(mappingFrom, serviceOutputMapping.Name); }
public async Task <IEnumerable <ServiceEntity> > GetAllServices(int baseId) { ServiceInput input = new ServiceInput(baseId, DateTime.Today.Date, await GetShortBase(baseId)); List <ServiceEntity> serviceData = (List <ServiceEntity>)(await GetServiceData(input)); if (serviceData == null) { return(new List <ServiceEntity>()); } await UpdateServiceData(serviceData, input); return(serviceData); }
public async Task <ActionResult <ServiceOutput> > Create(string serviceId, ServiceInput input) { return(await Execute(new CreateServiceController.Request() { Id = serviceId }).Transform(response => response.Service) .ToResult((response, controller) => CreatedAtAction("Get", new { branchId = BranchId, serviceId = serviceId }, response))); }
public void ServiceInput_FullName_NullNameAndShortTypeName() { //------------Setup for test-------------------------- const string mappingTo = "mapTo"; //------------Execute Test--------------------------- var serviceOutputMapping = new ServiceInput("", mappingTo) { ShortTypeName = "name" }; //------------Assert Results------------------------- Assert.IsNotNull(serviceOutputMapping); Assert.AreEqual("", serviceOutputMapping.FullName); }
public void ServiceInput_Constructor_EmptyConstructor_ShouldStillConstruct() { //------------Setup for test-------------------------- //------------Execute Test--------------------------- var serviceOutputMapping = new ServiceInput(); //------------Assert Results------------------------- Assert.IsNotNull(serviceOutputMapping); Assert.IsFalse(serviceOutputMapping.EmptyIsNull); Assert.IsFalse(serviceOutputMapping.RequiredField); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.Dev2ReturnType)); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.FullName)); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.ShortTypeName)); Assert.IsFalse(serviceOutputMapping.IsObject); }
public void ActionInputDatalistMapper_MapInputsToDatalist_IsNullOrEmpty_Should_Continue() { var serviceInputs = new List <IServiceInput>(); var serviceInput = new ServiceInput("[[a]]", ""); var serviceInputWithValue = new ServiceInput("[[b]]", "asdf"); serviceInputs.Add(serviceInput); serviceInputs.Add(serviceInputWithValue); Assert.AreEqual("", serviceInputs[0].Value); Assert.AreEqual("asdf", serviceInputs[1].Value); _actionInputDatalistMapper.MapInputsToDatalist(serviceInputs); Assert.AreEqual("[[a]]", serviceInputs[0].Value); Assert.AreEqual("asdf", serviceInputs[1].Value); }
public void ServiceInput_Constructor_EmptyName_ShouldStillConsturct() { //------------Setup for test-------------------------- const string mappingTo = "mapTo"; //------------Execute Test--------------------------- var serviceOutputMapping = new ServiceInput("", mappingTo); //------------Assert Results------------------------- Assert.IsNotNull(serviceOutputMapping); Assert.AreEqual(mappingTo, serviceOutputMapping.Value); Assert.AreEqual("", serviceOutputMapping.Name); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.Dev2ReturnType)); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.FullName)); Assert.IsTrue(string.IsNullOrEmpty(serviceOutputMapping.ShortTypeName)); Assert.IsFalse(serviceOutputMapping.IsObject); Assert.IsTrue(serviceOutputMapping.EmptyIsNull); Assert.IsTrue(serviceOutputMapping.RequiredField); }
public IToolRegion CloneRegion() { return(new DotNetMethodRegion { IsEnabled = IsEnabled, SelectedMethod = SelectedMethod == null ? null : new PluginAction { Inputs = SelectedMethod?.Inputs?.Select(a => { var serviceInput = new ServiceInput(a.Name, a.Value) as IServiceInput; serviceInput.IntellisenseFilter = a.IntellisenseFilter; return serviceInput; }).ToList(), FullName = SelectedMethod.FullName, Method = SelectedMethod.Method, } }); }
public async Task <IEnumerable <ServiceEntity> > GetServiceData(ServiceInput input) { const string STORE_PROCEDURE_NAME = "dbo.spu_ServiceSchedule"; try { using (IDbConnection db = GetConnection()) { var values = new { BaseID = input.BaseId, RptDate = input.Today, SvcDay = GetSvcDayForStoreProcedure(input.GetSvcDay()) }; await db.QueryAsync(STORE_PROCEDURE_NAME, values, commandType : CommandType.StoredProcedure); return(await db.QueryAsync <ServiceEntity>(GetServiceQuery(input.ShortBase))); } } catch (Exception) { throw; } }
public void GetDebugInputs_GivenEnvironmentMockEnvironmentAndFromPath_ShouldHaveOneDebugOutputs() { //---------------Set up test pack------------------- var sqlServerDatabaseActivity = CreateDsfSqlServerDatabaseActivity(); var serviceInputs = new List <IServiceInput>(); var serviceInput1 = new ServiceInput { Name = "name1", Value = "value1" }; serviceInputs.Add(serviceInput1); var serviceInput2 = new ServiceInput { Name = "name2", Value = "value2" }; serviceInputs.Add(serviceInput2); sqlServerDatabaseActivity.Inputs = serviceInputs; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var debugInputs = sqlServerDatabaseActivity.GetDebugInputs(CreateExecutionEnvironment(), 0); //---------------Test Result ----------------------- Assert.AreEqual(2, debugInputs.Count); Assert.AreEqual("name1", debugInputs[0].ResultsList[0].Label); Assert.AreEqual("value1", debugInputs[0].ResultsList[0].Value); Assert.AreEqual("name2", debugInputs[1].ResultsList[0].Label); Assert.AreEqual("value2", debugInputs[1].ResultsList[0].Value); }
private async Task UpdateServiceData(List <ServiceEntity> serviceData, ServiceInput input) { foreach (ServiceEntity serviceDataItem in serviceData) { if (double.TryParse(serviceDataItem.Lat, out double latitude) && double.TryParse(serviceDataItem.Lon, out double longitude)) { serviceDataItem.MGRS = ConvertToMGRS(latitude, longitude); } SetGeographicCoordinates(serviceDataItem); string weekDay = input.GetSvcDay(); serviceDataItem.MonRN = GetValueOf(weekDay, "RN", serviceDataItem); serviceDataItem.MonRO = GetValueOf(weekDay, "RO", serviceDataItem); if (Convert.ToBoolean(serviceDataItem.Pickup)) { serviceDataItem.MonRN = 1000; //Do not service continue; } else { if (serviceDataItem.PUDate != null) { if (serviceDataItem.PUDate.Date > new DateTime(1900, 12, 30).Date&& serviceDataItem.PUDate.Date <= input.Today.Date) { serviceDataItem.MonRN = 1000; //Do not service continue; } } if (serviceDataItem.DelDate != null) { if (serviceDataItem.DelDate.Date > new DateTime(1900, 12, 30).Date&& serviceDataItem.DelDate.Date >= input.Today.Date) { serviceDataItem.MonRN = 1000; //Do not service continue; } } if (serviceDataItem.SvcFreq != null) { switch (serviceDataItem.SvcFreq) { case ServiceFrequency.EveryOtherDay: if (await SetUpMonRNorSvcFreq(serviceDataItem, input, ServiceFrequency.EveryOtherDay)) { continue; } break; case ServiceFrequency.BiWeekly: if (await SetUpMonRNorSvcFreq(serviceDataItem, input, ServiceFrequency.BiWeekly)) { continue; } break; case ServiceFrequency.Monthly: if (await SetUpMonRNorSvcFreq(serviceDataItem, input, ServiceFrequency.Monthly)) { continue; } break; default: break; } } if (serviceDataItem.MonRN == 0) { serviceDataItem.MonRN = 99; } UpdateOrderNumberBasedOnShortBaseAndReqNumberValue(input, serviceDataItem); } } }
public async Task CreateService([FromServices] CreateServiceCommand command, [FromBody] ServiceInput input) { await command.Execute(input); }
public async Task <IActionResult> GetAsync([FromRoute, FromQuery] ServiceInput inpParameters) { var result = await gateway.AggregateResults(inpParameters.Services, inpParameters.IpAddress); return(Ok(result)); }
public async Task Execute(ServiceInput input) { await ServiceRepository.SaveAndFlushAsync(input.ToEntity()); }