/// <inheritdoc />
public async Task <OutputDataModel> ProcessAsync(InputDataModel input, InsightsModel graphModel)
{
return(await Task.Run(
() =>
{
var outputDataModel = new OutputDataModel();
var intersWithIncomStreets = input.Streets.Values
.Select(street => (street.EndIntersection, street.Name))
.GroupBy(tuple => tuple.EndIntersection, tuple => tuple.Name)
.ToList();
outputDataModel.Intersections = intersWithIncomStreets
.Select(
grouping => new IntersectionOptions
{
Id = grouping.Key,
IncomingStreets = grouping
.Select(
s => new StreetOptions
{
GreenLightDuration = RandomDuration,
StreetName = s
})
.ToList()
})
.ToDictionary(options => options.Id, options => options);
return outputDataModel;
}));
}
public static async Task PrintAsync(string fileName, OutputDataModel output)
{
Console.WriteLine($"[{fileName}]: writing..");
// if not exist then create
Directory.CreateDirectory(@"Resources\Outputs");
var outpFilePath = @$ "Resources\Outputs\{fileName}";
/// <summary>
///
/// </summary>
/// <param name="odm"></param>
/// <returns></returns>
public string WriteHeaders(OutputDataModel odm, bool useSuffix = true)
{
List <string> propertyNames = GetHeaders(odm, useSuffix);
if (propertyNames.Count == 0)
{
return("");
}
else
{
return(String.Join(",", propertyNames.ToArray()));
}
}
private List <OutputDataModel> Validation(List <InputDataModel> inputList)
{
List <OutputDataModel> outputList = new List <OutputDataModel>();
DateTime _date;
double _value;
foreach (var item in inputList)
{
if (String.IsNullOrEmpty(item.Date) || String.IsNullOrWhiteSpace(item.Date))
{
continue;
}
bool successDateTime = DateTime.TryParse(item.Date, out _date);
if (!successDateTime)
{
continue;
}
if (String.IsNullOrEmpty(item.Value) || String.IsNullOrWhiteSpace(item.Value))
{
continue;
}
bool successValue = double.TryParse(item.Value, NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), out _value);
if (!successValue)
{
continue;
}
if (String.IsNullOrEmpty(item.City) || String.IsNullOrWhiteSpace(item.City))
{
continue;
}
OutputDataModel model = new OutputDataModel()
{
Date = _date,
Value = _value,
City = item.City
};
outputList.Add(model);
}
return(outputList);
}
/// <summary>
///
/// </summary>
/// <param name="odm"></param>
/// <returns></returns>
public List <double> GetData(OutputDataModel odm)
{
List <double> propertyValues = new List <double>();
foreach (OutputDataElement v in odm.OutputDataElements)
{
if (v.PropertyInfo.PropertyType != typeof(DateTime))
{
if (v.IsSelected)
{
if (v.PropertyInfo.PropertyType.IsGenericType)
{
List <double> arrayValues = new List <double>();
foreach (double d in (IEnumerable <double>)v.PropertyInfo.GetValue(odm.HLController))
{
//All of these properties have an output attribute
arrayValues.Add(d);
}
propertyValues.AddRange(arrayValues.ToArray());
}
else
{
object value = v.PropertyInfo.GetValue(odm.HLController);
if (v.Output.Scale != 1)
{
propertyValues.Add(((double)value * v.Output.Scale));
}
else
{
if (value.GetType() == typeof(double))
{
propertyValues.Add((double)value);
}
else
{
propertyValues.Add((int)value);
}
}
}
}
}
}
return(propertyValues);
}
/// <summary>
///
/// </summary>
/// <param name="odm"></param>
/// <returns></returns>
public string WriteData(OutputDataModel odm)
{
List <double> propertyValues = GetData(odm);
List <string> propertyStringValues = new List <string>();
//foreach (double d in propertyValues)
// {
String.Join(",", propertyValues.ToArray());
//}
if (propertyValues.Count == 0)
{
return("");
}
else
{
return(String.Join(",", String.Join(",", propertyValues.ToArray())));
}
}
/// <summary>
///
/// </summary>
/// <param name="odm"></param>
/// <param name="useSuffix"></param>
/// <returns></returns>
public List <OutputDataElement> GetOutputs(OutputDataModel odm, bool useSuffix = true)
{
List <OutputDataElement> OutputDataElements = new List <OutputDataElement>();
string suffix = "";
if (useSuffix == true)
{
suffix = odm.Suffix;
}
foreach (OutputDataElement v in odm.OutputDataElements)
{
if (v.IsSelected)
{
if (v.PropertyInfo.PropertyType.IsGenericType)
{
int layerCount = 1;
foreach (double d in (IEnumerable <double>)v.PropertyInfo.GetValue(odm.HLController))
{
OutputDataElement o = Cloner.DeepClone(v);
o.Index = layerCount - 1;
o.Name = v.PropertyInfo.Name + "Layer" + layerCount.ToString() + (suffix == "" ? "" : ("-" + suffix));
o.HLController = odm.HLController;
o.PropertyInfo = v.PropertyInfo;
OutputDataElements.Add(o);
layerCount++;
}
}
else
{
OutputDataElements.Add(v);
v.Name = v.PropertyInfo.Name + (suffix == "" ? "" : ("-" + suffix));
v.HLController = odm.HLController;
}
}
}
return(OutputDataElements);
}
/// <inheritdoc />
public async Task OptimizeAsync(InputDataModel inputModel,
InsightsModel insightsModel,
OutputDataModel outputModel)
{
await Task.Run(
() =>
{
outputModel.Intersections.Values
.ToList()
.ForEach(
intersectionOptions =>
intersectionOptions.IncomingStreets = intersectionOptions.IncomingStreets
.Where(
street => insightsModel.TotalCarsPassByStreet.TryGetValue(street.StreetName, out var totalCars) &&
totalCars > 0)
.ToList());
outputModel.Intersections = outputModel.Intersections
.Where(pair => pair.Value.IncomingStreets.Any())
.ToDictionary(pair => pair.Key, pair => pair.Value);
});
}
/// <inheritdoc />
public async Task <OutputDataModel> AggregateAsync(List <OutputDataModel> models)
{
return(await Task.Run(
() =>
{
if (models.Count == 1)
{
return models.First();
}
var outputModel = new OutputDataModel();
var firstOutputDataModel = models.First();
foreach (var idAndIntersection in firstOutputDataModel.Intersections)
{
var intersectionId = idAndIntersection.Key;
var streets = idAndIntersection.Value.IncomingStreets;
var streetsByName = streets.ToDictionary(options => options.StreetName, options => options);
var intersectionFromOtherOutputs = models.Skip(1)
.Where(model => model.Intersections.ContainsKey(intersectionId))
.Select(model => model.Intersections[intersectionId])
.ToList();
var foundStreets = intersectionFromOtherOutputs
.SelectMany(
fromOther =>
fromOther.IncomingStreets
.Where(incStreet => streetsByName.ContainsKey(incStreet.StreetName)))
.GroupBy(incStreet => incStreet.StreetName)
.ToDictionary(grouping => grouping.Key, grouping => grouping.ToList());
var intersectionOptionsUpdated = new IntersectionOptions();
var streetOptionsUpdated = streets
.Select(
street =>
{
if (foundStreets.TryGetValue(street.StreetName, out var relatedStreets))
{
return new StreetOptions
{
StreetName = street.StreetName,
GreenLightDuration =
(street.GreenLightDuration
+ relatedStreets.Sum(relStreet => relStreet.GreenLightDuration))
/ (1 + relatedStreets.Count)
};
}
return street;
})
.ToList();
intersectionOptionsUpdated.Id = intersectionId;
intersectionOptionsUpdated.IncomingStreets.AddRange(
streetOptionsUpdated);
outputModel.Intersections.Add(intersectionId, intersectionOptionsUpdated);
}
return outputModel;
}));
}
public IActionResult SearchForm(InputDataModel InputData)
{
try
{
string cmdToTSql = "ar_Search6_new @Date1=@Date1,@Date2=@Date2,@ProjectsFoldersCards=@ProjectsFoldersCards,@checkFile=@checkFile";
List <SqlParameter> sp = new List <SqlParameter>();
sp.Add(new SqlParameter("@Date1", InputData.Date1));
sp.Add(new SqlParameter("@Date2", InputData.Date2));
sp.Add(new SqlParameter("@ProjectsFoldersCards", Convert.ToInt32(InputData.Target)));
sp.Add(new SqlParameter("@checkFile", Convert.ToInt32(InputData.CheckFile)));
if (InputData.ProjectName != null)
{
sp.Add(new SqlParameter("@ProjectName", $"%{InputData.ProjectName}%"));
cmdToTSql += ",@ProjectName=@ProjectName";
}
if (InputData.InvEntoryNumber != null)
{
sp.Add(new SqlParameter("@InvEntoryNumber", $"{InputData.InvEntoryNumber}"));
cmdToTSql += ",@InvEntoryNumber=@InvEntoryNumber";
}
if (InputData.PromyselCode != null)
{
sp.Add(new SqlParameter("@PromyselCode", $"%{InputData.PromyselCode}%"));
cmdToTSql += ",@PromyselCode=@PromyselCode";
}
if (InputData.PromyselName != null)
{
sp.Add(new SqlParameter("@PromyselName", $"%{InputData.PromyselName}%"));
cmdToTSql += ",@PromyselName=@PromyselName";
}
if (InputData.PloshCode != null)
{
sp.Add(new SqlParameter("@PloshCode", $"%{InputData.PloshCode}%"));
cmdToTSql += ",@PloshCode=@PloshCode";
}
if (InputData.PloshName != null)
{
sp.Add(new SqlParameter("@PloshName", $"%{InputData.PloshName}%"));
cmdToTSql += ",@PloshName=@PloshName";
}
if (InputData.PositionCode != null)
{
sp.Add(new SqlParameter("@PositionCode", $"%{InputData.PositionCode}%"));
cmdToTSql += ",@PositionCode=@PositionCode";
}
if (InputData.PositionName != null)
{
sp.Add(new SqlParameter("@PositionName", $"%{InputData.PositionName}%"));
cmdToTSql += ",@PositionName=@PositionName";
}
if (InputData.MarkCode != null)
{
sp.Add(new SqlParameter("@MarkCode", $"%{InputData.MarkCode}%"));
cmdToTSql += ",@MarkCode=@MarkCode";
}
if (InputData.MarkName != null)
{
sp.Add(new SqlParameter("@MarkName", $"%{InputData.MarkName}%"));
cmdToTSql += ",@MarkName=@MarkName";
}
if (InputData.ProjectCode != null)
{
sp.Add(new SqlParameter("@ProjectCode", InputData.ProjectCode));
cmdToTSql += ",@ProjectCode=@ProjectCode";
}
if (InputData.ProjectStage != null)
{
sp.Add(new SqlParameter("@ProjectStage", InputData.ProjectStage));
cmdToTSql += ",@ProjectStage=@ProjectStage";
}
if (InputData.Leaftypename != null)
{
sp.Add(new SqlParameter("@Leaftypename", InputData.Leaftypename));
cmdToTSql += ",@Leaftypename=@Leaftypename";
}
if (InputData.PaperFormatName != null)
{
sp.Add(new SqlParameter("@PaperFormatName", InputData.PaperFormatName));
cmdToTSql += ",@PaperFormatName=@PaperFormatName";
}
if (InputData.LeafNumber != null)
{
sp.Add(new SqlParameter("@LeafNumber", InputData.LeafNumber));
cmdToTSql += ",@LeafNumber=@LeafNumber";
}
if (InputData.organization != null)
{
sp.Add(new SqlParameter("@organization", InputData.organization));
cmdToTSql += ",@organization=@organization";
}
if (InputData.Otdel != null)
{
sp.Add(new SqlParameter("@Otdel", InputData.Otdel));
cmdToTSql += ",@Otdel=@Otdel";
}
var Data = _context._OutputDataModels.FromSqlRaw(cmdToTSql, sp.ToArray());
ListOutputModel listOutput = new ListOutputModel();
foreach (var dataRow in Data)
{
OutputDataModel output = new OutputDataModel();
output.Csid = dataRow.Csid;
output.FolderName = dataRow.FolderName;
output.Hn = dataRow.Hn;
output.Pid = dataRow.Pid;
output.Uid = dataRow.Uid;
output.code = dataRow.code;
listOutput.listOutputData.Add(output);
}
return(View("ResultCollection", listOutput));
}
catch (Exception ex)
{
_Logger.Error(ex.Message);
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="odm"></param>
/// <param name="useSuffix"></param>
/// <returns></returns>
public List <string> GetHeaders(OutputDataModel odm, bool useSuffix = true)
{
return(new List <string>(GetOutputs(odm, useSuffix).Select(x => x.Name)));
}
public void InitOutputModel()
{
this.Output = new OutputDataModel(this);
}
public IOutputDataModel <TData> Output <TData>(OperationResult result, TData data)
{
return(OutputDataModel <TData> .CreateResult(result, data));
}
public IOutputDataModel <TData> SuccessOutput <TData>(TData data)
{
return(OutputDataModel <TData> .CreateSuccessResult(data));
}