public ActionResult Descargar(string tipo, string reportId, string primarykey)
{
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
var tipoDocumento = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), tipo);
Guid usuario = ContextService.Id;
string name = reportId;
ViewBag.Tipo = (int)tipoDocumento;
ViewBag.Usuario = usuario.ToString();
var model = new DesignModel
{
Url = reportId,
Report = service.GetDocumentoParaImprimir(tipoDocumento, usuario, name)?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(tipoDocumento, ContextService, primarykey).DataSource,
Name = name
};
var report = new XtraReport();
using (var ms = new MemoryStream(model.Report))
{
report.LoadLayout(ms);
report.DataSource = model.DataSource;
report.Name = model.Name;
using (var stream = new MemoryStream())
{
report.ExportToPdf(stream);
return(File(stream.GetBuffer(), "application/pdf"));
}
}
}
public ActionResult Visualizar(string tipo, string reportId, string primarykey)
{
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
TipoDocumentoImpresion tipoDocumento = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), tipo);
Guid usuario = ContextService.Id;
string name = reportId;
Dictionary <string, object> dictionary = null;
if (primarykey.IsValidJson())
{
dictionary = JsonConvert.DeserializeObject <Dictionary <string, object> >(primarykey);
}
ViewBag.Tipo = (int)tipoDocumento;
ViewBag.Usuario = usuario.ToString();
var model = new DesignModel
{
Url = reportId,
Report = service.GetDocumentoParaImprimir(tipoDocumento, usuario, name)?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(tipoDocumento, ContextService, primarykey).DataSource,
Parameters = dictionary,
Name = name
};
Session["ReportViewer"] = model;
return(View(model));
}
public ActionResult EditDesign(DesignModel model)
{
try
{
string image = model.Url;
for (int i = 0; i < Request.Files.Count; i++)
{
HttpPostedFileBase file = Request.Files[i];
if (file.ContentLength > 0)
{
string fileName = Guid.NewGuid() + "." + file.FileName.Split('.')[1];
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory + "screenshots\\", fileName);
file.SaveAs(path);
image = "/screenshots/" + fileName;
}
}
if (model.Id > 0)
{
var obj = _db.Designs.Where(x => x.Id == model.Id && x.IsDeleted == false).FirstOrDefault();
obj.Html = model.Html;
obj.CategoryId = model.Fk_Category;
obj.ImageUrl = image;
obj.UpdatedOn = DateTime.UtcNow;
_db.Entry(obj).State = System.Data.Entity.EntityState.Modified;
_db.SaveChanges();
}
else
{
var obj = new Design()
{
CategoryId = model.Fk_Category,
Html = model.Html,
ImageUrl = image,
CreatedOn = DateTime.UtcNow,
IsDeleted = false
};
_db.Entry(obj).State = System.Data.Entity.EntityState.Added;
_db.SaveChanges();
}
return(RedirectToAction("Design"));
}
catch (Exception ex)
{
throw ex;
}
}
private byte[] UrlFile(FicherosEmailModel item)
{
var mierror = "";
var result = new byte[0];
try
{
using (var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos)))
{
var vector = item.Url.Split(';');
var primarykey = vector[0];
var TipoDocumentoImpresion = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), vector[1]);
var reportId = vector[2];
var model = new DesignModel
{
Url = reportId,
Report = service.GetDocumento(TipoDocumentoImpresion, ContextService.Id, reportId)?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(TipoDocumentoImpresion, ContextService, primarykey).DataSource,
Name = string.Format("{0}", item.Nombre)
};
var report = new XtraReport();
using (var ms = new MemoryStream(model.Report))
{
report.LoadLayout(ms);
report.DataSource = model.DataSource;
report.Name = model.Name;
using (var stream = new MemoryStream())
{
report.ExportToPdf(stream);
result = stream.GetBuffer();
}
}
}
}
catch (Exception ex)
{
mierror = ex.Message;
}
return(result);
}
public ActionResult EditDesign(long?Id)
{
try
{
DesignModel model;
if (Id != null)
{
model = _db.Designs.Where(x => x.Id == Id && x.IsDeleted == false).Select(x => new DesignModel()
{
Id = x.Id,
Fk_Category = x.CategoryId,
Html = x.Html,
Url = x.ImageUrl
}).FirstOrDefault();
model.Categories = _db.Categories.Where(x => x.IsDeleted == false).Select(x => new CategoryModel()
{
Id = x.Id,
Name = x.Name
}).ToList();
}
else
{
model = new DesignModel();
model.Categories = _db.Categories.Where(x => x.IsDeleted == false).Select(x => new CategoryModel()
{
Id = x.Id,
Name = x.Name
}).ToList();
}
return(View(model));
}
catch (Exception ex)
{
throw ex;
}
}
public DesignsViewActor(DesignViewModel designViewModel, ModMetadata modMetadata)
{
// TODO : move to coordinator
//IActorRef stringTableActorRef = Context.ActorOf(Props.Create(() => new ModStringTableActor(modMetadata)));
//IActorRef designOperationsActorRef = Context.ActorOf(Props.Create(() => new DesignOperationsActor(modMetadata)));
int processorCount = Environment.ProcessorCount;
Receive <LoadDesignsCommand>(command => { designOperationsActorRef.Tell(command); });
Receive <CloseDesignsViewCommand>(@event =>
{
Self.Tell(PoisonPill.Instance);
var viewClosedEvent = new DesignViewClosedEvent(@event.DesignViewModel);
Context.System.EventStream.Publish(viewClosedEvent);
});
Receive <DesignsLoadedEvent>(async @event =>
{
using (var mat = Context.Materializer())
{
IList <StringTableValueLoadedEvent> events = new List <StringTableValueLoadedEvent>();
await Source.From(@event.Designs)
.SelectAsync(processorCount,
design => stringTableActorRef.Ask(
new LoadStringTableValueFromIdCommand(design.Name ?? -1, "english")))
.Select(o => (StringTableValueLoadedEvent)o)
.RunWith(Sink.ForEach <StringTableValueLoadedEvent>(loadedEvent => events.Add(loadedEvent)), mat)
.PipeTo(Self, Self,
() =>
{
IList <DesignModel> designModels = new List <DesignModel>(@event.Designs.Count);
foreach (Design eventDesign in @event.Designs)
{
var stringTableValue = events.FirstOrDefault(loadedEvent =>
loadedEvent.StId == eventDesign.Name);
DesignModel designModel = new DesignModel(eventDesign.Id, eventDesign.DesignId,
eventDesign.CountryDesignerRef?.Code, eventDesign.TypeRef,
stringTableValue?.StValue,
eventDesign.Speed, eventDesign.Sensors, eventDesign.GunRange,
eventDesign.GunPrecision, eventDesign.GunDamage, eventDesign.MissilePayload,
eventDesign.MissileRange, eventDesign.MissilePrecision,
eventDesign.MissileDamage, eventDesign.Stealth, eventDesign.Countermeasures,
eventDesign.Armor, eventDesign.Piece1, eventDesign.Piece2, eventDesign.Piece3,
eventDesign.Texture);
designModels.Add(designModel);
}
designViewModel.Designs = new ObservableCollection <DesignModel>(designModels);
return(designModels);
});
}
});
}
private DesignModel CreateDesignModel(int featureCount)
{
_designModel = _designModelBuilder.BuilDesignModel(_designModelSize, featureCount);
return(_designModel);
}
// Only accept ComponentAssembly and DesignContainer
public static DesignModel Convert(CyPhy.DesignEntity de)
{
if (!(de.Kind == "ComponentAssembly" || de.Kind == "DesignContainer"))
{
return(null);
}
ResetCache();
var dm = new DesignModel {
Name = de.Name
};
Container rootContainerType = null;
if (de is CyPhy.ComponentAssembly)
{
String s_ID = (de as CyPhy.ComponentAssembly).Attributes.ConfigurationUniqueID;
if (string.IsNullOrEmpty(s_ID))
{
s_ID = Guid.NewGuid().ToString("B");
(de as CyPhy.ComponentAssembly).Attributes.ConfigurationUniqueID = s_ID;
}
if (s_ID.IndexOf("{") != 0)
{
// Add curly braces
s_ID = string.Concat("{", s_ID, "}");
}
dm.DesignID = s_ID;
rootContainerType = new Compound();
}
else if (de is CyPhy.DesignContainer)
{
dm.DesignID = (de as CyPhy.DesignContainer).Impl.GetGuidDisp();
switch (((CyPhy.DesignContainer)de).Attributes.ContainerType)
{
case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound:
rootContainerType = new Compound();
break;
case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Alternative:
rootContainerType = new Alternative();
break;
case CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Optional:
rootContainerType = new Optional();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
// Add single ContainerType for the root level Container
dm.Containers.AddItem(rootContainerType);
rootContainerType.Name = de.Name;
rootContainerType.id = GetOrSetID(de);
// Update DesignModel by calling recursive update method
var innerPortInstances = new Dictionary <CyPhy.Port, PortInstance>();
var containerPortInstances = new Dictionary <CyPhy.Port, ContainerPort>();
var innerStructuralPortInstances = new Dictionary <CyPhy.Port, StructuralInterfaceInstance>();
var containerStructuralPortInstances = new Dictionary <CyPhy.Port, ContainerStructuralInterface>();
var connections = new List <Connection>();
var simpleFormulas = new Dictionary <CyPhy.SimpleFormula, ContainerCalculation>();
// Can contain: ContainerNamedValue/ContainerCalculation/ComponentNamedValueInstance
var valueInstances = new Dictionary <CyPhy.ValueFlowTarget, AVM.META.Design.ValueType>();
UpdateSubContainers(new DesignPrimitivesWrapper(de), rootContainerType, dm, innerPortInstances, containerPortInstances, connections, simpleFormulas, valueInstances, innerStructuralPortInstances, containerStructuralPortInstances);
#region Create AllPorts dictionary
var allPorts = new Dictionary <CyPhy.Port, AbstractPort>();
foreach (var portInstance in innerPortInstances)
{
allPorts.Add(portInstance.Key, portInstance.Value);
}
foreach (var containerPort in containerPortInstances)
{
allPorts.Add(containerPort.Key, containerPort.Value);
}
#endregion
#region Create AllStructuralPorts dictionary
var allStructuralPorts = new Dictionary <CyPhy.Port, AbstractStructuralInterface>();
foreach (var abstractPortInstance in innerStructuralPortInstances)
{
allStructuralPorts.Add(abstractPortInstance.Key, abstractPortInstance.Value);
}
foreach (var abstractContainerPort in containerStructuralPortInstances)
{
allStructuralPorts.Add(abstractContainerPort.Key, abstractContainerPort.Value);
}
#endregion
#region Join Structures -> PortConnectors
// Pair construct
//ConvertJoinStructures(dm, innerPortInstances, connections.OfType<CyPhy.JoinStructures>());
// Grouping construct
//ConvertJoinStrucutresInGroups(GetStructuralPortGroups(allPorts, connections.OfType<CyPhy.JoinStructures>()), dm, allPorts);
// Pair construct
#endregion
#region ValueFlow -> ValueConnector
ConvertValueFlows(dm, connections.OfType <CyPhy.ValueFlow>(), simpleFormulas, allPorts, valueInstances);
#endregion
return(dm);
}
private static void UpdateSubContainers(DesignPrimitivesWrapper de,
Container rootContainerType,
DesignModel rootDesignModel,
Dictionary <CyPhy.Port, PortInstance> cyphyPorts2PortInstances,
Dictionary <CyPhy.Port, ContainerPort> containerPorts,
List <Connection> connectionsToBeVisited,
Dictionary <CyPhy.SimpleFormula, ContainerCalculation> simpleFormulas,
Dictionary <CyPhy.ValueFlowTarget, AVM.META.Design.ValueType> valueInstances,
Dictionary <CyPhy.Port, StructuralInterfaceInstance> innerStructuralPortInstances,
Dictionary <CyPhy.Port, ContainerStructuralInterface> containerStructuralPortInstances)
{
System.Diagnostics.Debug.WriteLine(de.Path);
// Init list
if (rootContainerType.ContainerPorts == null)
{
rootContainerType.ContainerPorts = new List <ContainerPort>();
}
rootContainerType.ComponentInstances = new List <ComponentInstance>();
// Add Powerflows, JointStrucutres and ValueFlows for later steps
connectionsToBeVisited.AddRange(de.ValueFlows);
#region Handle ComponentRefs
var componentRefs = de.ComponentRefs;
foreach (var compRef in componentRefs)
{
var isComponent = false;
try
{
var c = compRef.Referred.Component;
// line above throws an exception if it is not a component
isComponent = true;
}
catch
{
}
if (compRef != null && isComponent)
{
CyPhy.Component comp = compRef.Referred.Component;
System.Diagnostics.Debug.WriteLine(comp.Path);
ComponentInstance compInst = Component2ComponentInstance(comp);
rootContainerType.ComponentInstances.AddItem(compInst);
compInst.Name = compRef.Name;
//compInst.id = GetOrSetID(compRef);
//compInst.id = compRef.Guid.ToString();
String instanceGUID = compRef.Attributes.InstanceGUID;
// Set this value if not set
if (String.IsNullOrWhiteSpace(instanceGUID))
{
compRef.Attributes.InstanceGUID = compRef.Guid.ToString();
instanceGUID = compRef.Attributes.InstanceGUID;
}
compInst.id = compRef.Attributes.InstanceGUID;
String s_SrcDesignSpaceContainerID = GetDesignSpaceSourceObjectID(compRef);
if (!String.IsNullOrWhiteSpace(s_SrcDesignSpaceContainerID))
{
compInst.SrcDesignSpaceContainerID = s_SrcDesignSpaceContainerID;
}
// Update Component's PortInstances
compInst.PortInstances = new List <PortInstance>();
foreach (CyPhy.Port port in comp.Children.PortCollection)
{
#if TRACK_PORT_ID
var portInst = new PortInstance {
IDinSourceModel = port.ID
};
#else
var portInst = new PortInstance {
IDinSourceModel = port.Attributes.ID
};
#endif
//var portInst = new PortInstance { IDinSourceModel = port.ID };
compInst.PortInstances.AddItem(portInst);
if (!cyphyPorts2PortInstances.ContainsKey(port))
{
cyphyPorts2PortInstances.Add(port, portInst); // Update Ports list
}
}
// Convert parameters
foreach (var p in comp.Children.ParameterCollection)
{
double result = 0;
double.TryParse(p.Attributes.Value, out result);
var componentNamedValueInstance = new ComponentNamedValueInstance {
IDinComponentModel = p.Attributes.ID, Value = result
};
compInst.NamedValueInstances.AddItem(componentNamedValueInstance);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, componentNamedValueInstance);
}
// Convert properties
foreach (var p in comp.Children.PropertyCollection)
{
double result = 0;
double.TryParse(p.Attributes.Value, out result);
var componentNamedValueInstance = new ComponentNamedValueInstance {
IDinComponentModel = p.Attributes.ID, Value = result
};
compInst.NamedValueInstances.AddItem(componentNamedValueInstance);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, componentNamedValueInstance);
}
}
}
#endregion
#region Handle Component instances
List <CyPhy.Component> lcChildComps = de.Components;
foreach (CyPhy.Component comp in lcChildComps)
{
System.Diagnostics.Debug.WriteLine(comp.Path);
ComponentInstance compInst = Component2ComponentInstance(comp);
rootContainerType.ComponentInstances.AddItem(compInst);
// Update Component's PortInstances
compInst.PortInstances = new List <PortInstance>();
foreach (CyPhy.Port port in comp.Children.PortCollection)
{
#if TRACK_PORT_ID
var structPort = new StructuralInterfaceInstance {
IDinSourceModel = port.ID
};
#else
var structPort = new StructuralInterfaceInstance {
IDinSourceModel = port.Attributes.ID
};
#endif
if (!innerStructuralPortInstances.ContainsKey(port))
{
innerStructuralPortInstances.Add(port, structPort);
compInst.StructuralInterfaceInstances.Add(structPort);
}
#if TRACK_PORT_ID
var portInst = new PortInstance {
IDinSourceModel = port.ID
};
#else
var portInst = new PortInstance {
IDinSourceModel = port.Attributes.ID
};
#endif
compInst.PortInstances.AddItem(portInst);
if (!cyphyPorts2PortInstances.ContainsKey(port))
{
cyphyPorts2PortInstances.Add(port, portInst); // Update Ports list
}
}
// Convert parameters
foreach (var p in comp.Children.ParameterCollection)
{
double result = 0;
double.TryParse(p.Attributes.Value, out result);
var componentNamedValueInstance = new ComponentNamedValueInstance {
IDinComponentModel = p.Attributes.ID, Value = result
};
compInst.NamedValueInstances.AddItem(componentNamedValueInstance);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, componentNamedValueInstance);
}
// Convert properties
foreach (var p in comp.Children.PropertyCollection)
{
double result = 0;
double.TryParse(p.Attributes.Value, out result);
var componentNamedValueInstance = new ComponentNamedValueInstance {
IDinComponentModel = p.Attributes.ID, Value = result
};
compInst.NamedValueInstances.AddItem(componentNamedValueInstance);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, componentNamedValueInstance);
}
}
#endregion
// Recursively add all ContainerTypes from sub-DesignEntities
rootContainerType.Containers = new List <Container>();
var ldeDesignEntityChildren = de.ComponentAssemblies.Cast <CyPhy.DesignEntity>().ToList();
ldeDesignEntityChildren.AddRange(de.DesignContainers);
foreach (CyPhy.DesignEntity subDE in ldeDesignEntityChildren)
{
Container subRootContainerType;
if (subDE is CyPhy.DesignContainer &&
(subDE as CyPhy.DesignContainer).Attributes.ContainerType == CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Compound)
{
subRootContainerType = new Compound();
}
else if (subDE is CyPhy.DesignContainer &&
(subDE as CyPhy.DesignContainer).Attributes.ContainerType == CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Alternative)
{
subRootContainerType = new Alternative();
}
else if (subDE is CyPhy.DesignContainer &&
(subDE as CyPhy.DesignContainer).Attributes.ContainerType == CyPhyClasses.DesignContainer.AttributesClass.ContainerType_enum.Optional)
{
subRootContainerType = new Optional();
}
else if (subDE is CyPhy.ComponentAssembly)
{
subRootContainerType = new Compound();
}
else
{
continue;
}
subRootContainerType.Name = subDE.Name;
subRootContainerType.id = GetOrSetID(subDE);
rootContainerType.Containers.AddItem(subRootContainerType);
UpdateSubContainers(new DesignPrimitivesWrapper(subDE), subRootContainerType, rootDesignModel, cyphyPorts2PortInstances, containerPorts, connectionsToBeVisited, simpleFormulas, valueInstances, innerStructuralPortInstances, containerStructuralPortInstances);
}
#region Elements on the current container
// Convert simple formulas
foreach (var sf in de.SimpleFormulas)
{
var containerCalculation = new ContainerCalculation();
rootContainerType.ContainerValues.AddItem(containerCalculation);
simpleFormulas[sf] = containerCalculation;
}
// Add container ports (from ports)
foreach (var port in de.Ports)
{
if (containerPorts.ContainsKey(port))
{
continue;
}
var pi = new ContainerPort();
containerPorts.Add(port, pi);
rootContainerType.ContainerPorts.AddItem(pi);
}
// Convert parameters
foreach (var p in de.Parameters)
{
var containerNamedValue = new ContainerNamedValue {
IsParameter = true, Value = p.Attributes.Value
};
rootContainerType.ContainerValues.AddItem(containerNamedValue);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, containerNamedValue);
}
// Convert properties
foreach (var p in de.Properties)
{
var containerNamedValue = new ContainerNamedValue {
IsParameter = false, Value = p.Attributes.Value
};
rootContainerType.ContainerValues.AddItem(containerNamedValue);
if (valueInstances.ContainsKey(p))
{
continue;
}
valueInstances.Add(p, containerNamedValue);
}
#endregion
}
//Add port group to the design model from joinstructures
private static void ConvertJoinStrucutresInGroups(IEnumerable <HashSet <CyPhy.Port> > portGroups, DesignModel dm, Dictionary <CyPhy.Port, AbstractPort> allPorts)
{
foreach (var currentGroup in portGroups)
{
var pc = new PortConnector {
EndPoints = new List <AbstractPort>()
};
foreach (var h in currentGroup.Where(allPorts.ContainsKey))
{
var a = allPorts[h];
pc.EndPoints.AddItem(a);
}
dm.Connectors.AddItem(pc);
}
}
// Add ComponentNamedValueInstances to the design model
private static void ConvertValueFlows(DesignModel dm, IEnumerable <CyPhy.ValueFlow> valueFlowConnectors, Dictionary <CyPhy.SimpleFormula, ContainerCalculation> simpleFormulaCache, Dictionary <CyPhy.Port, AbstractPort> allPorts, Dictionary <CyPhy.ValueFlowTarget, AVM.META.Design.ValueType> valueInstances)
{
#region Param -> SimpleFormula
foreach (var valueFlowConnector in valueFlowConnectors.Where(x => x.GenericSrcEnd.Kind == "Parameter" && x.GenericDstEnd.Kind == "SimpleFormula"))
{
var src = CyPhyClasses.Parameter.Cast(valueFlowConnector.GenericSrcEnd.Impl);
var dst = CyPhyClasses.SimpleFormula.Cast(valueFlowConnector.GenericDstEnd.Impl);
if (!valueInstances.ContainsKey(src) || !simpleFormulaCache.ContainsKey(dst))
{
continue;
}
dm.Connectors.AddItem(new ValueConnector
{
SourceValue = valueInstances[src],
DestinationValue = simpleFormulaCache[dst]
});
}
#endregion
#region SimpleFormula -> Param
foreach (var valueFlowConnector in valueFlowConnectors.Where(x => x.GenericDstEnd.Kind == "Parameter" && x.GenericSrcEnd.Kind == "SimpleFormula"))
{
var src = CyPhyClasses.SimpleFormula.Cast(valueFlowConnector.GenericSrcEnd.Impl);
var dst = CyPhyClasses.Parameter.Cast(valueFlowConnector.GenericDstEnd.Impl);
if (!valueInstances.ContainsKey(dst) || !simpleFormulaCache.ContainsKey(src))
{
continue;
}
dm.Connectors.AddItem(new ValueConnector
{
SourceValue = simpleFormulaCache[src],
DestinationValue = valueInstances[dst]
});
}
#endregion
#region Property -> SimpleFormula
foreach (var valueFlowConnector in valueFlowConnectors.Where(x => x.GenericSrcEnd.Kind == "Property" && x.GenericDstEnd.Kind == "SimpleFormula"))
{
var src = CyPhyClasses.Property.Cast(valueFlowConnector.GenericSrcEnd.Impl);
var dst = CyPhyClasses.SimpleFormula.Cast(valueFlowConnector.GenericDstEnd.Impl);
if (!valueInstances.ContainsKey(src) || !simpleFormulaCache.ContainsKey(dst))
{
continue;
}
dm.Connectors.AddItem(new ValueConnector
{
SourceValue = valueInstances[src],
DestinationValue = simpleFormulaCache[dst]
});
}
#endregion
#region SimpleFormula -> Property
foreach (var valueFlowConnector in valueFlowConnectors.Where(x => x.GenericDstEnd.Kind == "Property" && x.GenericSrcEnd.Kind == "SimpleFormula"))
{
var src = CyPhyClasses.SimpleFormula.Cast(valueFlowConnector.GenericSrcEnd.Impl);
var dst = CyPhyClasses.Property.Cast(valueFlowConnector.GenericDstEnd.Impl);
if (!valueInstances.ContainsKey(dst) || !simpleFormulaCache.ContainsKey(src))
{
continue;
}
dm.Connectors.AddItem(new ValueConnector
{
SourceValue = simpleFormulaCache[src],
DestinationValue = valueInstances[dst]
});
}
#endregion
#region Param -> Param
foreach (var valueFlowConnector in valueFlowConnectors.Where(x => x.GenericDstEnd.Kind == "Parameter" && x.GenericSrcEnd.Kind == "Parameter"))
{
var src = CyPhyClasses.Parameter.Cast(valueFlowConnector.GenericSrcEnd.Impl);
var dst = CyPhyClasses.Parameter.Cast(valueFlowConnector.GenericDstEnd.Impl);
if (!valueInstances.ContainsKey(dst) || !valueInstances.ContainsKey(src))
{
continue;
}
dm.Connectors.AddItem(new ValueConnector
{
SourceValue = valueInstances[src],
DestinationValue = valueInstances[dst]
});
}
#endregion
}