internal override ResultBase ExcuteImplementation(ParameterBase parameter)
{
MaskParameter p = (MaskParameter)parameter;
MasksApi maskApi = new IO.Swagger.Api.MasksApi(ApiConfiguration);
BufferApi bufferApi = new IO.Swagger.Api.BufferApi(ApiConfiguration);
var bufferResponse = bufferApi.BufferInsertAdvanced(1, "Test File", new MemoryStream(Encoding.UTF8.GetBytes("FILE DI TEST RANDOM " + Guid.NewGuid())));
var maskSchema = maskApi.MasksGetProfileSchemaByMaskId(p.MaskId);
// Completo i campi
var fieldDocname = (SubjectFieldDTO)maskSchema.Fields.First(x => x is SubjectFieldDTO);
fieldDocname.Value = "Test performance WEB API";
var combo39_9 = (AdditionalFieldComboDTO)maskSchema.Fields.First(x => string.Equals(x.Name, "COMBO39_9"));
var combo40_9 = (AdditionalFieldComboDTO)maskSchema.Fields.First(x => string.Equals(x.Name, "COMBO40_9"));
var testo22_5 = (AdditionalFieldStringDTO)maskSchema.Fields.First(x => string.Equals(x.Name, "TESTO22_5"));
var testo21_5 = (AdditionalFieldStringDTO)maskSchema.Fields.First(x => string.Equals(x.Name, "TESTO21_5"));
combo39_9.Value = "PRATICHE";
combo40_9.Value = "E";
testo22_5.Value = Guid.NewGuid().ToString("N");
testo21_5.Value = testo22_5.Value.Substring(2, 5);
var profileDto = new ProfileDTO {
Fields = maskSchema.Fields, Document = new FileDTO(new List <string>(), bufferResponse)
};
ProfileResultDTO result = maskApi.MasksPost(p.MaskId, profileDto);
return(new DocnumberResult {
Docnumber = result.DocNumber.Value
});
}
private void GenerateProperty(TypeBuilder typeBuilder, ParameterBase parameter, ModuleBuilder moduleBuilder)
{
Type dataType = parameter.DataType;
if ((parameter.AllowedValues != null) && (parameter.AllowedValues.Length > 0))
{
dataType = GenerateEnumeration(parameter.Name + "Enum", parameter.AllowedValues, moduleBuilder);
}
FieldBuilder fieldBuilder = typeBuilder.DefineField(parameter.Name + "Field", dataType, FieldAttributes.Private);
PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(parameter.Name, PropertyAttributes.HasDefault, dataType, null);
MethodBuilder propertyGetBuilder = typeBuilder.DefineMethod("get_" + parameter.Name,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
dataType,
null);
ILGenerator getGenerator = propertyGetBuilder.GetILGenerator();
getGenerator.Emit(OpCodes.Ldarg_0);
getGenerator.Emit(OpCodes.Ldfld, fieldBuilder);
getGenerator.Emit(OpCodes.Ret);
MethodBuilder propertySetBuilder = typeBuilder.DefineMethod("get_" + parameter.Name,
MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null,
new Type[] { dataType });
ILGenerator setGenerator = propertySetBuilder.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldarg_1);
setGenerator.Emit(OpCodes.Stfld, fieldBuilder);
setGenerator.Emit(OpCodes.Ret);
AssociateAttribute(propertyBuilder, typeof(DescriptionAttribute), parameter.Description);
AssociateAttribute(propertyBuilder, typeof(DisplayNameAttribute), parameter.DisplayName);
propertyBuilder.SetGetMethod(propertyGetBuilder);
propertyBuilder.SetSetMethod(propertySetBuilder);
}
/// <summary>
/// Update the row containment associated to a <see cref="ParameterBase"/>
/// </summary>
/// <param name="parameterBase">The <see cref="ParameterBase"/></param>
public void UpdateParameterBasePosition(ParameterBase parameterBase)
{
var oldContainer = this.parameterOrOverrideContainerMap[parameterBase];
var newContainer = parameterBase.Group;
var associatedRow = this.parameterOrOverrideBaseCache[parameterBase];
if (newContainer != null && oldContainer == null)
{
this.ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterOrOverrideContainerMap[parameterBase] = newContainer;
}
else if (newContainer == null && oldContainer != null)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.ContainedRows.SortedInsert(associatedRow, ChildRowComparer);
this.parameterOrOverrideContainerMap[parameterBase] = null;
}
else if (newContainer != null && oldContainer != null && newContainer != oldContainer)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterOrOverrideContainerMap[parameterBase] = newContainer;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterStateRowViewModel"/> class
/// </summary>
/// <param name="parameterBase">The associated <see cref="ParameterBase"/></param>
/// <param name="option">The associated <see cref="Option"/></param>
/// <param name="actualState">The associated <see cref="ActualFiniteState"/></param>
/// <param name="session">The associated <see cref="ISession"/></param>
/// <param name="containerViewModel">The container row</param>
/// <param name="isDialogReadOnly">Value indicating whether this row should be read-only because the dialog is read-only</param>
public ParameterStateRowViewModel(ParameterBase parameterBase, Option option, ActualFiniteState actualState, ISession session, IRowViewModelBase <Thing> containerViewModel, bool isDialogReadOnly = false)
: base(parameterBase, session, option, actualState, containerViewModel, 0, isDialogReadOnly)
{
this.Name = this.ActualState.Name;
this.State = this.ActualState.Name;
this.Option = this.ActualOption;
}
private ParameterProxy CreateParameterProxy(ParameterBase param, EntityData _entity)
{
ParameterProxy proxy = null;
if (param is Parameter_Boolean)
{
proxy = new ParameterProxy_Boolean(_entity, (Parameter_Boolean)param);
}
else if (param is Parameter_Integer)
{
proxy = new ParameterProxy_Integer(_entity, (Parameter_Integer)param);
}
else if (param is Parameter_Double)
{
proxy = new ParameterProxy_Double(_entity, (Parameter_Double)param);
}
else if (param is Parameter_DoubleRange)
{
proxy = new ParameterProxy_DoubleRange(_entity, (Parameter_DoubleRange)param);
}
else if (param is Parameter_String)
{
proxy = new ParameterProxy_String(_entity, (Parameter_String)param);
}
else if (param is Parameter_List)
{
proxy = new ParameterProxy_List(_entity, (Parameter_List)param);
}
else if (param is Parameter_Vector3)
{
proxy = new ParameterProxy_Vector3(_entity, (Parameter_Vector3)param);
}
return(proxy);
}
public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
base.OnNavigatedTo(e, viewModelState);
var parameter = ParameterBase.ToObject <NovelDetailParameter>((string)e.Parameter);
Initialize(parameter);
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterOptionRowViewModel"/> class
/// </summary>
/// <param name="parameterBase">The associated <see cref="ParameterBase"/></param>
/// <param name="option">The associated <see cref="Option"/></param>
/// <param name="session">The associated <see cref="ISession"/></param>
/// <param name="containerViewModel">The container row</param>
/// <param name="isReadOnly">A value indicating whether the row is read-only</param>
public ParameterOptionRowViewModel(ParameterBase parameterBase, Option option, ISession session, IViewModelBase <Thing> containerViewModel, bool isReadOnly)
: base(parameterBase, session, option, null, containerViewModel, 0, isReadOnly)
{
this.Name = this.ActualOption.Name;
this.Option = this.ActualOption;
Func <ObjectChangedEvent, bool> discriminator = objectChange => objectChange.EventKind == EventKind.Updated;
Action <ObjectChangedEvent> action = x => { this.Name = this.ActualOption.Name; };
if (this.AllowMessageBusSubscriptions)
{
var optionListener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(this.Option)
.Where(discriminator)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(action);
this.Disposables.Add(optionListener);
}
else
{
var optionObserver = CDPMessageBus.Current.Listen <ObjectChangedEvent>(typeof(Option));
this.Disposables.Add(
this.MessageBusHandler.GetHandler <ObjectChangedEvent>().RegisterEventHandler(optionObserver, new ObjectChangedMessageBusEventHandlerSubscription(this.Option, discriminator, action)));
}
}
public static List <Declaration> GetChunkDeclarations()
{
if (OnDemandProcessingManager.m_ChunkDeclarations == null)
{
List <Declaration> list = new List <Declaration>(21);
list.Add(ScopeInstance.GetDeclaration());
list.Add(ReportInstance.GetDeclaration());
list.Add(DataSetInstance.GetDeclaration());
list.Add(DataRegionInstance.GetDeclaration());
list.Add(DataRegionMemberInstance.GetDeclaration());
list.Add(DataCellInstance.GetDeclaration());
list.Add(DataAggregateObjResult.GetDeclaration());
list.Add(SubReportInstance.GetDeclaration());
list.Add(GroupTreePartition.GetDeclaration());
list.Add(ReportSnapshot.GetDeclaration());
list.Add(ParametersImplWrapper.GetDeclaration());
list.Add(ParameterImplWrapper.GetDeclaration());
list.Add(SubReportInfo.GetDeclaration());
list.Add(ParameterInfo.GetNewDeclaration());
list.Add(ParameterInfoCollection.GetDeclaration());
list.Add(ParameterBase.GetNewDeclaration());
list.Add(ValidValue.GetNewDeclaration());
list.Add(FieldInfo.GetDeclaration());
list.Add(TreePartitionManager.GetDeclaration());
list.Add(LookupObjResult.GetDeclaration());
list.Add(DataCellInstanceList.GetDeclaration());
return(list);
}
return(OnDemandProcessingManager.m_ChunkDeclarations);
}
public void ResetAndReload()
{
target.Reset();
target.DeleteInstance();
target = null;
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
}
public override void AddParameter(ParameterBase param)
{
if (!_parameters.Contains(param))
{
_parameters.Add(param);
}
}
/// <summary>
/// Update the row containment associated to a <see cref="ParameterBase"/>
/// </summary>
/// <param name="parameterBase">The <see cref="ParameterBase"/></param>
public void UpdateParameterBasePosition(ParameterBase parameterBase)
{
try
{
var oldContainer = this.parameterBaseContainerMap[parameterBase];
var newContainer = parameterBase.Group;
var associatedRow = this.parameterBaseCache[parameterBase];
if (newContainer != null && oldContainer == null)
{
this.ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterBaseContainerMap[parameterBase] = newContainer;
}
else if (newContainer == null && oldContainer != null)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.ContainedRows.SortedInsert(associatedRow, ChildRowComparer);
this.parameterBaseContainerMap[parameterBase] = null;
}
else if (newContainer != null && oldContainer != null && newContainer != oldContainer)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterBaseContainerMap[parameterBase] = newContainer;
}
}
catch (Exception exception)
{
logger.Error(exception, "A problem occured when executing the UpdateParameterBasePosition method.");
}
}
protected void CloneParameters(ParameterBase iiToCopyFrom)
{
foreach (Parameter p in iiToCopyFrom.Parameters)
{
Parameters.Add((Parameter)p.Clone());
}
}
public void ParameterBase_FOO()
{
string testName = "FOO";
ParameterBase testParameter = new ParameterBase();
testParameter.Name = testName;
Assert.AreEqual(testName, testParameter.Name);
}
internal override ResultBase ExcuteImplementation(ParameterBase parameter)
{
var p = (MaskParameter)parameter;
Dm_Profile_Insert_MV forInsert = Wcf.ARX_DATI.Dm_Profile_Insert_MV_GetNewInstance_From_DmMaskId(p.MaskId);
var insertMask = forInsert.DmProfileDefault.Dm_Profile_Insert_Base.To_Dm_Profile_Insert_For_Mask();
insertMask.DmMaskId = p.MaskId;
insertMask.DocName = "Test performance WCF";
insertMask.File = new Arx_File(Encoding.UTF8.GetBytes("FILE DI TEST RANDOM " + Guid.NewGuid()), "Test.txt", DateTime.Now);
insertMask.DataDoc = DateTime.Now.Date;
var combo39_9 = (Aggiuntivo_String)insertMask.Aggiuntivi.First(x => string.Equals(x.Nome, "COMBO39_9"));
var combo40_9 = (Aggiuntivo_String)insertMask.Aggiuntivi.First(x => string.Equals(x.Nome, "COMBO40_9"));
var testo22_5 = (Aggiuntivo_String)insertMask.Aggiuntivi.First(x => string.Equals(x.Nome, "TESTO22_5"));
var testo21_5 = (Aggiuntivo_String)insertMask.Aggiuntivi.First(x => string.Equals(x.Nome, "TESTO21_5"));
combo39_9.Valore = "PRATICHE";
combo40_9.Valore = "E";
testo22_5.Valore = Guid.NewGuid().ToString("N");
testo21_5.Valore = testo22_5.Valore.Substring(2, 5);
var result = Wcf.ARX_DATI.Dm_Profile_Insert_For_Mask(insertMask);
if (result.EXCEPTION != Security_Exception.Nothing)
{
throw new Exception(result.EXCEPTION.ToString());
}
return(new DocnumberResult {
Docnumber = result.PROFILE.DOCNUMBER
});
}
public override void CreateModule(ParameterBase Parameter)
{
parCylineDoor = Parameter as ParCylinderDoor;
if (parCylineDoor == null)
{
return;
}
init();
PartDocument part = InventorTool.CreatePart();
PartComponentDefinition partDef = part.ComponentDefinition;
PlanarSketch osketch = partDef.Sketches.Add(partDef.WorkPlanes[3]);
SketchEllipticalArc Arc1 = osketch.SketchEllipticalArcs.Add(InventorTool.Origin, InventorTool.Left, parCylineDoor.DoorRadius, parCylineDoor.InRadius, 0, Math.PI / 2);
SketchEllipticalArc Arc2 = osketch.SketchEllipticalArcs.Add(InventorTool.Origin, InventorTool.Left, parCylineDoor.DoorRadius + parCylineDoor.Thickness, parCylineDoor.InRadius + parCylineDoor.Thickness, 0, Math.PI / 2);
osketch.GeometricConstraints.AddConcentric((SketchEntity)Arc1, (SketchEntity)Arc2);
SketchLine Line1 = osketch.SketchLines.AddByTwoPoints(Arc1.StartSketchPoint, Arc2.StartSketchPoint);
SketchLine Line2 = osketch.SketchLines.AddByTwoPoints(Arc1.EndSketchPoint, Arc2.EndSketchPoint);
osketch.GeometricConstraints.AddHorizontalAlign(Arc1.StartSketchPoint, Arc1.CenterSketchPoint);
osketch.GeometricConstraints.AddVerticalAlign(Arc1.EndSketchPoint, Arc1.CenterSketchPoint);
osketch.GeometricConstraints.AddHorizontal((SketchEntity)Line1);
osketch.GeometricConstraints.AddVertical((SketchEntity)Line2);
osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, true, InventorTool.TranGeo.CreatePoint2d(-parCylineDoor.DoorRadius / 2, 0));
osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, false, InventorTool.TranGeo.CreatePoint2d(0, -parCylineDoor.InRadius / 2));
Point2d p = InventorTool.TranGeo.CreatePoint2d((Line1.StartSketchPoint.Geometry.X + Line1.EndSketchPoint.Geometry.X) / 2 + 1, (Line1.StartSketchPoint.Geometry.Y + Line1.EndSketchPoint.Geometry.Y) / 2 + 1);
osketch.DimensionConstraints.AddTwoPointDistance(Line1.StartSketchPoint, Line1.EndSketchPoint, DimensionOrientationEnum.kAlignedDim, p);
Profile profile = osketch.Profiles.AddForSolid();
RevolveFeature revolve = partDef.Features.RevolveFeatures.AddFull(profile, Line1, PartFeatureOperationEnum.kNewBodyOperation);
}
public static ParameterBase[] GetParameters(ParsingData parser, ParameterDefineNode[] defineNodes)
{
ParameterBase[] parameters = new ParameterBase[defineNodes.Length];
for (int i = 0; i < parameters.Length; i++)
{
EnumData enumData = null;
DefinedType type = null;
if (defineNodes[i].Type != null)
{
enumData = EnumData.GetEnum(defineNodes[i].Type);
type = parser.GetDefinedType(defineNodes[i].Type, null);
if (enumData == null && type == null)
{
throw SyntaxErrorException.NonexistentType(defineNodes[i].Type, defineNodes[i].Location);
}
}
if (enumData != null)
{
parameters[i] = new EnumParameter(defineNodes[i].VariableName, enumData.Type);
}
else if (type != null)
{
parameters[i] = new TypeParameter(defineNodes[i].VariableName, type);
}
else
{
parameters[i] = new Parameter(defineNodes[i].VariableName, Elements.ValueType.Any, null);
}
}
return(parameters);
}
/// <summary>
/// Update the row containment associated to a <see cref="ParameterBase"/>
/// </summary>
/// <param name="parameterBase">The <see cref="ParameterBase"/></param>
public void UpdateParameterBasePosition(ParameterBase parameterBase)
{
var parameter = parameterBase as Parameter;
if (parameter == null)
{
throw new InvalidOperationException("An element definition row may not contain parameter override rows.");
}
var oldContainer = this.parameterContainerMap[parameter];
var newContainer = parameterBase.Group;
var associatedRow = this.parameterCache[parameter];
if (newContainer != null && oldContainer == null)
{
this.ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterContainerMap[parameter] = newContainer;
}
else if (newContainer == null && oldContainer != null)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.ContainedRows.SortedInsert(associatedRow, ChildRowComparer);
this.parameterContainerMap[parameter] = null;
}
else if (newContainer != null && oldContainer != null && newContainer != oldContainer)
{
this.parameterGroupCache[oldContainer].ContainedRows.Remove(associatedRow);
this.parameterGroupCache[newContainer].ContainedRows.SortedInsert(associatedRow, ParameterGroupRowViewModel.ChildRowComparer);
this.parameterContainerMap[parameter] = newContainer;
}
}
internal static List <Declaration> GetChunkDeclarations()
{
if (m_ChunkDeclarations == null)
{
return(new List <Declaration>(21)
{
ScopeInstance.GetDeclaration(),
ReportInstance.GetDeclaration(),
DataSetInstance.GetDeclaration(),
DataRegionInstance.GetDeclaration(),
DataRegionMemberInstance.GetDeclaration(),
DataCellInstance.GetDeclaration(),
DataAggregateObjResult.GetDeclaration(),
SubReportInstance.GetDeclaration(),
GroupTreePartition.GetDeclaration(),
ReportSnapshot.GetDeclaration(),
ParametersImplWrapper.GetDeclaration(),
ParameterImplWrapper.GetDeclaration(),
SubReportInfo.GetDeclaration(),
ParameterInfo.GetNewDeclaration(),
ParameterInfoCollection.GetDeclaration(),
ParameterBase.GetNewDeclaration(),
ValidValue.GetNewDeclaration(),
FieldInfo.GetDeclaration(),
TreePartitionManager.GetDeclaration(),
LookupObjResult.GetDeclaration(),
DataCellInstanceList.GetDeclaration()
});
}
return(m_ChunkDeclarations);
}
protected void OnEmberTreeChanged(object sender, Dispatcher.GlowRootReadyArgs e)
{
// Triggered on EmBER+ tree change
Console.WriteLine("OnEmberTreeChanged");
try
{
GlowQualifiedParameter glowParameter = e.Root.FirstOrDefault() as GlowQualifiedParameter;
ParameterBase changedParameter = GetElement <ParameterBase>(glowParameter?.Path);
if (glowParameter != null)
{
Console.WriteLine($"EmberTree node {glowParameter.Value.ToString()} //IdentifierPath changed. {changedParameter?.IdentifierPath}");
Debug.WriteLine($"INFO {glowParameter.GetType().ToString()}");
Task.Run(async() =>
{
Console.WriteLine($"EmberTree node {glowParameter.Value.ToString()} //IdentifierPath changed. {changedParameter?.IdentifierPath}");
await OnHandleValuesChanged(changedParameter);
// TODO: Add event for saving tree
});
}
}
catch (Exception ex)
{
Console.WriteLine("ERROR parsing tree");
Console.Write(ex);
}
}
private async Task OnHandleValuesChanged(ParameterBase parameter)
{
// Path
var identifierPath = parameter.IdentifierPath;
// Check if it is string parameter
var stringParameter = parameter as StringParameter;
if (stringParameter != null)
{
ChangedTreeEvent?.Invoke(identifierPath, stringParameter.Value, stringParameter.Path);
}
var boolParameter = parameter as BooleanParameter;
if (boolParameter != null)
{
ChangedTreeEvent?.Invoke(identifierPath, boolParameter.Value, boolParameter.Path);
}
var intParameter = parameter as IntegerParameter;
if (intParameter != null)
{
ChangedTreeEvent?.Invoke(identifierPath, (int)intParameter.Value, intParameter.Path);
}
}
internal override ResultBase ExcuteImplementation(ParameterBase parameter)
{
var p = (DocnumberParameter)parameter;
Wcf.ARX_DATI.Dm_Profile_MV_GetData_By_Docnumber(p.Docnumber, string.Empty, true);
return(new VoidResult());
}
/// <summary>
/// Move the parameter to the given parameter group.
/// </summary>
/// <param name="parameter">The <see cref="Parameter" /> whose group will change</param>
/// <param name="group">The <see cref="ParameterGroup" /></param>
/// <param name="transaction">the <see cref="ThingTransaction" /> holding the changes to persist</param>
private void MoveParameterToGroup(ParameterBase parameter, ParameterGroup group, ThingTransaction transaction)
{
if (parameter != null && group != null && parameter.Group != group)
{
parameter.Group = group;
transaction.CreateOrUpdate(parameter);
Console.WriteLine($"Moved parameter {parameter.ParameterType.ShortName} to group {group.Name}");
}
}
public override void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
base.OnNavigatedTo(e, viewModelState);
var parameter = ParameterBase.ToObject <IllustDetailParameter>((string)e.Parameter);
_categoryService.UpdateCategory();
Thumbnailable = new PixivImage(parameter.Illust, _imageStoreService, true);
}
public bool Initialize(ParameterBase Parameters)
{
CameraClient.Init();
this.cameraParameter = Parameters as IPCameraParameter;
this.cameraClient = new CameraClient();
int error = this.cameraClient.Login(this.cameraParameter.Address, this.cameraParameter.Port, this.cameraParameter.UserName, this.cameraParameter.Password, this.cameraParameter.DeviceSpecification, this.cameraParameter.DeviceSN);
return(error <= 0);
}
public override bool Compare(ParameterBase other)
{
CustomConfigParameter customConfigParameter = other as CustomConfigParameter;
if (ConfigFileName != customConfigParameter?.ConfigFileName)
{
return(false);
}
return(true);
}
internal override ResultBase ExcuteImplementation(ParameterBase parameter)
{
var p = (DocnumberParameter)parameter;
var profileApi = new IO.Swagger.Api.ProfilesApi(ApiConfiguration);
profileApi.ProfilesGet(p.Docnumber);
return(new VoidResult());
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterStateRowViewModel"/> class
/// </summary>
/// <param name="parameterBase">The associated <see cref="ParameterBase"/></param>
/// <param name="option">The associated <see cref="Option"/></param>
/// <param name="actualState">The associated <see cref="ActualFiniteState"/></param>
/// <param name="session">The associated <see cref="ISession"/></param>
/// <param name="containerViewModel">The container row</param>
/// <param name="isReadOnly">A value indicating whether the row is read-only</param>
public ParameterStateRowViewModel(ParameterBase parameterBase, Option option, ActualFiniteState actualState, ISession session, IRowViewModelBase <Thing> containerViewModel, bool isReadOnly)
: base(parameterBase, session, option, actualState, containerViewModel, 0, isReadOnly)
{
this.Name = this.ActualState.Name;
this.State = this.ActualState.Name;
this.IsDefault = this.ActualState.IsDefault;
this.Option = this.ActualOption;
this.InitializeOptionSubscriptions();
}
internal override ResultBase ExcuteImplementation(ParameterBase parameter)
{
var p = (MaskParameter)parameter;
var apiMask = new IO.Swagger.Api.MasksApi(ApiConfiguration);
MaskDTO maskDto = apiMask.MasksGetById(p.MaskId);
return(new VoidResult());
}
public override void CreateModule(ParameterBase Parameter)
{
parCylinder = Parameter as ParCylinder;
if (parCylinder == null)
{
return;
}
init();
PartDocument part = InventorTool.CreatePart();
PartComponentDefinition partDef = part.ComponentDefinition;
PlanarSketch osketch = partDef.Sketches.Add(partDef.WorkPlanes[3]);
SketchEllipticalArc Arc1, Arc2;
SketchLine Line1, Line2;
CreateLines(osketch, out Arc1, out Line1, parCylinder.CapRadius, parCylinder.InRadius, parCylinder.Length);
//SketchLine line5= offsetLine<SketchLine>(osketch, Line1, 2, true);
//SketchOffsetSpline arc5 = (SketchOffsetSpline)offsetLine(osketch, Arc1, 2, true);
//SketchLine Line3 = osketch.SketchLines.AddByTwoPoints(Arc1.StartSketchPoint, arc5.StartSketchPoint);
//SketchLine Line4 = osketch.SketchLines.AddByTwoPoints(Line1.EndSketchPoint, line5.EndSketchPoint);
//osketch.GeometricConstraints.AddHorizontal((SketchEntity)Line3);
//osketch.GeometricConstraints.AddVertical((SketchEntity)Line4);
//osketch.GeometricConstraints.AddEqualLength(Line3, Line4);
//osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, true, InventorTool.TranGeo.CreatePoint2d(-parCylinder.CapRadius / 2, 0));
//osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, false, InventorTool.TranGeo.CreatePoint2d(0, -parCylinder.InRadius / 2));
//Point2d p = InventorTool.TranGeo.CreatePoint2d((Line1.StartSketchPoint.Geometry.X + Line1.EndSketchPoint.Geometry.X) / 2, (Line1.StartSketchPoint.Geometry.Y + Line1.EndSketchPoint.Geometry.Y) / 2 + 1);
//osketch.DimensionConstraints.AddTwoPointDistance(Line1.StartSketchPoint, Line1.EndSketchPoint, DimensionOrientationEnum.kAlignedDim, p);
//p = InventorTool.TranGeo.CreatePoint2d((Line4.StartSketchPoint.Geometry.X + Line4.EndSketchPoint.Geometry.X) / 2 + 1, (Line4.StartSketchPoint.Geometry.Y + Line4.EndSketchPoint.Geometry.Y) / 2);
//osketch.DimensionConstraints.AddTwoPointDistance(Line4.StartSketchPoint, Line4.EndSketchPoint, DimensionOrientationEnum.kAlignedDim, p);
CreateLines(osketch, out Arc2, out Line2, parCylinder.CapRadius + parCylinder.Thickness, parCylinder.InRadius + parCylinder.Thickness, parCylinder.Length);
SketchLine Line3 = osketch.SketchLines.AddByTwoPoints(Arc1.StartSketchPoint, Arc2.StartSketchPoint);
SketchLine Line4 = osketch.SketchLines.AddByTwoPoints(Line1.EndSketchPoint, Line2.EndSketchPoint);
osketch.GeometricConstraints.AddHorizontalAlign(Arc1.StartSketchPoint, Arc1.CenterSketchPoint);
osketch.GeometricConstraints.AddVerticalAlign(Arc1.EndSketchPoint, Arc1.CenterSketchPoint);
osketch.GeometricConstraints.AddHorizontal((SketchEntity)Line3);
osketch.GeometricConstraints.AddVertical((SketchEntity)Line4);
osketch.GeometricConstraints.AddEqualLength(Line3, Line4);
osketch.GeometricConstraints.AddConcentric((SketchEntity)Arc1, (SketchEntity)Arc2);
// osketch.GeometricConstraints.AddCoincident((SketchEntity)InventorTool.Origin, (SketchEntity)Arc1.CenterSketchPoint);
osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, true, InventorTool.TranGeo.CreatePoint2d(-parCylinder.CapRadius / 2, 0));
osketch.DimensionConstraints.AddEllipseRadius((SketchEntity)Arc1, false, InventorTool.TranGeo.CreatePoint2d(0, -parCylinder.InRadius / 2));
Point2d p = InventorTool.TranGeo.CreatePoint2d((Line1.StartSketchPoint.Geometry.X + Line1.EndSketchPoint.Geometry.X) / 2, (Line1.StartSketchPoint.Geometry.Y + Line1.EndSketchPoint.Geometry.Y) / 2 + 1);
osketch.DimensionConstraints.AddTwoPointDistance(Line1.StartSketchPoint, Line1.EndSketchPoint, DimensionOrientationEnum.kAlignedDim, p);
p = InventorTool.TranGeo.CreatePoint2d((Line4.StartSketchPoint.Geometry.X + Line4.EndSketchPoint.Geometry.X) / 2 + 1, (Line4.StartSketchPoint.Geometry.Y + Line4.EndSketchPoint.Geometry.Y) / 2);
osketch.DimensionConstraints.AddTwoPointDistance(Line4.StartSketchPoint, Line4.EndSketchPoint, DimensionOrientationEnum.kAlignedDim, p);
CreateRibs(osketch, Line2);
Profile profile = osketch.Profiles.AddForSolid();
RevolveFeature revolve = partDef.Features.RevolveFeatures.AddFull(profile, Line3, PartFeatureOperationEnum.kNewBodyOperation);
}
private void UpdateUnitValue(ParameterDto parameter, ParameterBase param)
{
if (parameter is AnalogParameterDto analog &&
param is AnalogParameter analogParameterEntity)
{
var unit = _mapper.Map <Unit>(analog.Unit);
_db.Entry(unit)
.State = EntityState.Unchanged;
analogParameterEntity.Unit = unit;
}
}
public override bool Compare(ParameterBase other)
{
var developerModeParameter = other as DeveloperModeParameter;
if (DeveloperModeOn != developerModeParameter?.DeveloperModeOn)
{
return(false);
}
return(true);
}
private void GetTarget()
{
foreach (Type type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.Name == parameterClassName)
{
PropertyInfo instanceMember = type.GetProperty("Instance");
target = instanceMember.GetValue(null, null) as ParameterBase;
}
}
}
internal static IDictionary <string, object> ApplyParameter(
[NotNull] this IDictionary <string, object> dict,
[CanBeNull] ParameterBase paramOrNull)
{
if (dict == null)
{
throw new ArgumentNullException(nameof(dict));
}
paramOrNull?.SetDictionary(dict);
return(dict);
}
public void HandleReport(ParameterBase reportToHandle)
{
if ((reportToHandle != null) && (reportToHandle.Type == typeof(string)))
{
Reports.Add(reportToHandle);
if (reportToHandle.Name == "Combinatorial")
{
CombinatorialParameter<string> newParameter = (CombinatorialParameter<string>)reportToHandle;
Combinatorials.Add(newParameter.Combinatorial);
}
else if (reportToHandle.Name == "CombinatorialTier")
{
CombinatorialTierParameter<string> newParameter = (CombinatorialTierParameter<string>)reportToHandle;
Tier = newParameter.Tier;
}
}
}
public abstract bool RemoveParameter(ParameterBase param);
public override bool RemoveParameter(ParameterBase param)
{
return _parameters.Remove(param);
}
public TweeterQuery(ParameterBase param)
: this()
{
AddParameter(param);
}
public static TweeterQuery Create(ParameterBase param)
{
return new TweeterQuery(param);
}
protected bool ParametersAreTheSame(ParameterBase comparisonFunction, ComparisonDepth depth)
{
if (Parameters.Count != comparisonFunction.Parameters.Count) return false;
for (int i = 0; i < Parameters.Count; i++)
{
if (depth != ComparisonDepth.Signature && Parameters[i].Name != comparisonFunction.Parameters[i].Name)
return false;
if (Parameters[i].DataType != comparisonFunction.Parameters[i].DataType)
{
return false;
}
}
return true;
}
public void ParameterBase_Errors()
{
ParameterBase testParameter = new ParameterBase();
Assert.IsNotNull(testParameter.Errors);
}
public void ParameterBase_Empty()
{
string testName_01 = "FOO";
string testName_02 = string.Empty;
ParameterBase testParameter = new ParameterBase();
testParameter.Name = testName_01;
Assert.AreEqual(testName_01, testParameter.Name);
testParameter.Name = testName_02;
Assert.AreEqual(testName_02, testParameter.Name);
}
public void ParameterBase_Text()
{
ParameterBase testParameter = new ParameterBase();
Assert.AreEqual(string.Empty, testParameter.Text);
}
public abstract void AddParameter(ParameterBase param);
public void ParameterBase_Null()
{
string testName_01 = "FOO";
string testName_02 = null;
ParameterBase testParameter = new ParameterBase();
testParameter.Name = testName_01;
Assert.AreEqual(testName_01, testParameter.Name);
testParameter.Name = testName_02;
Assert.AreEqual(testName_01, testParameter.Name);
Assert.IsTrue(testParameter.HasErrors);
}
public void ParameterBase_Type()
{
ParameterBase testParameter = new ParameterBase();
Assert.AreEqual(typeof(ParameterBase).ToString(), testParameter.Type.ToString());
}
public CmdletParameterSwitchValuePair(string parameterSwitch, ParameterBase value)
{
this.ParameterSwitch = parameterSwitch;
this.Value = value;
}
public void ParameterBase_HasErrors()
{
ParameterBase testParameter = new ParameterBase();
Assert.IsFalse(testParameter.HasErrors);
}