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());
}
