public static MenuItemDataProperty CreateMenuItem(IProperty p, LimnorContextMenuCollection menus)
{
PropertyPointer pp = p as PropertyPointer;
if (pp != null)
{
return(new PropertyItem(p.Name, menus.Owner, pp.Info));
}
else
{
PropertyClass pc = p as PropertyClass;
if (pc != null)
{
return(new PropertyItemClassPointer(p.Name, menus.Owner, pc));
}
else
{
IPropertyWrapper w = p as IPropertyWrapper;
if (w != null)
{
}
}
}
throw new DesignerException("Unsupported property type {0} for CreateMenuItem", p.GetType());
}
public override void OnReadFromXmlNode(IXmlCodeReader serializer, XmlNode node)
{
base.OnReadFromXmlNode(serializer, node);
PropertyId = XmlUtil.GetAttributeUInt(node, XMLATTR_PropertyId);
PropertyClassId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID);
XmlObjectReader reader = (XmlObjectReader)serializer;
if (PropertyClassId == 0)
{
PropertyClassId = reader.ObjectList.ClassId;
}
ClassPointer root = ClassPointer.CreateClassPointer(PropertyClassId, reader.ObjectList.Project);
PropertyClass mc = root.GetCustomPropertyById(PropertyId);
if (mc == null)
{
MathNode.LogError(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"Property {0} not found in class {1}", PropertyId, root.ClassId));
}
else
{
_property = mc;
}
}
public void TrySetProperty_WhenValueTypeDoesNotMatchProperty_ThrowsInvalidOperationException()
{
var testClass = new PropertyClass();
var exception = Assert.Catch <InvalidOperationException>(() => testClass.TrySetProperty(nameof(PropertyClass.Writable), 0));
Assert.AreEqual("Property type is not assignable from the Value type.", exception.Message);
}
public void SetProperty_WhenTypeObjectIsNull_ReturnsTypeObjectUnchanged()
{
PropertyClass testClass = null;
var result = testClass.SetProperty(a => a.Writable, It.IsAny <string>());
Assert.AreEqual(testClass, result);
}
private void BtnLogin_Click(object sender, EventArgs e)
{
try
{
accountProperty = accountMgr.CheckNameAndPasswd(textBox1.Text.Trim(), maskedTextBox1.Text.Trim());
Logger.Info(accountProperty.UserId + "," + accountProperty.Job + " logged in");
}
catch (Exception ex)
{
MessageBox.Show("Can not connect to the server.Please contact the admin");
Logger.Error(ex.StackTrace);
return;
}
if (accountProperty == null)
{
MessageBox.Show("Invalid Name or Password");
}
else
{
UserInfo.UserId = accountProperty.UserId;
UserInfo.UserName = accountProperty.AccountName;
UserInfo.Job = (JobDescription)accountProperty.Job;
MainFrame mainFrame = new MainFrame();
this.Hide();
mainFrame.WindowState = FormWindowState.Maximized;
mainFrame.Show();
}
}
public void OnSetDefinition()
{
if (_definingClass == null)
{
throw new DesignerException("Defining class not loaded for accessing properties for class {0}", _definingClassId);
}
_classVersion = _definingClass.EditVersion;
XmlNode classXmlNode = _definingClass.XmlData;
_typeName = XmlUtil.GetNameAttribute(classXmlNode);
_properties = new List <PropertyClassDescriptor>();
Dictionary <string, PropertyClass> ps = _definingClass.CustomProperties;
foreach (PropertyClass p in ps.Values)
{
if (p.Implemented && p.AccessControl == EnumAccessControl.Public)
{
PropertyClass p0 = (PropertyClass)p.Clone();
p0.SetHolder(this);
_properties.Add(new PropertyClassDescriptor(p0));
}
}
if (string.IsNullOrEmpty(_iconFilename))
{
_iconFilename = SerializeUtil.ReadIconFilename(classXmlNode);
}
}
private void setScope(SetterClass setter)
{
_prop = setter.Property;
SetDataType(_prop.PropertyType);
Method = setter;
init();
}
public static PropertyField Property(this PanelCreator self, PropertyClass target, Rcon.Property property)
{
var control = self.panel.AddChild <PropertyField>();
control.SetTarget(target, property);
return(control);
}
public void TrySetProperty_WhenClassObjectIsNull_ReturnsUnchangedObject()
{
PropertyClass testClass = null;
var result = testClass.TrySetProperty(nameof(PropertyClass.Writable), It.IsAny <string>());
Assert.AreEqual(testClass, result);
}
public void TrySetProperty_WhenClassDoesNotHaveProperty_ReturnsUnchangedObject()
{
var testClass = new PropertyClass();
var result = testClass.TrySetProperty("Random", It.IsAny <string>());
Assert.AreEqual(testClass, result);
}
public void SetProperty_WhenTryingToSetAReadonlyProperty_ThrowsInvalidOperationException()
{
var testClass = new PropertyClass();
var exception = Assert.Catch <InvalidOperationException>(() => testClass.SetProperty(a => a.Readonly, It.IsAny <string>()));
Assert.AreEqual("Cannot set a restricted property.", exception.Message);
}
public void WorkOrderResponseMaps()
{
var workOrder = new Helpers.StubGeneration.Generator <WorkOrder>()
.AddDefaultGenerators()
.Generate();
AppointmentDetails appointment = new AppointmentDetails
{
Date = DateTime.UtcNow,
Description = "test",
End = DateTime.UtcNow,
Start = DateTime.UtcNow
};
var response = workOrder.ToResponse(appointment, new Uri("https://managementAddress.none"), canAssignOperative: false);
PropertyClass propertyClass = workOrder.Site?.PropertyClass.FirstOrDefault();
string addressLine = propertyClass?.Address?.AddressLine;
response.CallerNumber.Should().Be(workOrder.Customer.Person.Communication.Where(cc => cc.Channel.Medium == RepairsApi.V2.Generated.CommunicationMediumCode._20).FirstOrDefault()?.Value);
response.CallerName.Should().Be(workOrder.Customer.Person.Name.Full);
response.DateRaised.Should().Be(workOrder.DateRaised);
response.Description.Should().Be(workOrder.DescriptionOfWork);
response.Owner.Should().Be(workOrder.AssignedToPrimary.Name);
response.Priority.Should().Be(workOrder.WorkPriority.PriorityDescription);
response.PriorityCode.Should().Be(workOrder.WorkPriority.PriorityCode);
response.Property.Should().Be(addressLine);
response.PropertyReference.Should().Be(workOrder.Site?.PropertyClass.FirstOrDefault()?.PropertyReference);
response.Reference.Should().Be(workOrder.Id);
response.Target.Should().Be(workOrder.WorkPriority.RequiredCompletionDateTime);
response.Property.Should().Be(addressLine);
response.ExternalAppointmentManagementUrl.ToString().Should().Contain(workOrder.ExternalSchedulerReference);
response.CanAssignOperative.Should().BeFalse();
response.PlannerComments.Should().Be(workOrder.PlannerComments);
}
public void SetProperty_WhenPassingThroughAValueOfDifferentType_ThrowsInvalidOperationException()
{
var testClass = new PropertyClass();
var exception = Assert.Catch <InvalidOperationException>(() => testClass.SetProperty(a => a.Writable, 3));
Assert.AreEqual("Value type does not match the Property type.", exception.Message);
}
protected override void OnSetImage()
{
if (_property == null && Designer != null)
{
ClassPointer root = Designer.GetRootId();
_property = root.GetCustomPropertyById(PropertyId);
}
if (_property != null)
{
if (_property.RunAt == EnumWebRunAt.Client)
{
SetIconImage(Resources._custPropClient.ToBitmap());
}
else if (_property.RunAt == EnumWebRunAt.Server)
{
SetIconImage(Resources._custPropServer.ToBitmap());
}
else
{
SetIconImage(Resources._custProp.ToBitmap());
}
}
else
{
SetIconImage(Resources._custProp.ToBitmap());
}
}
private void ReadPropertyFile()
{
//Method which is used to read tyhe property file.
string fileContent = System.IO.File.ReadAllText(PROPERTY_FILE_PATH); // Reads the content of the file.
if (!fileContent.Contains(",")) // Checks if the file contains a period ",". If not, then leaves the method.
{
return;
}
string[] values = fileContent.Split(','); // If it does have one, than the file contains data. Split on the periods "," creating a string array.
foreach (PropertyClass property in list) // Check for same name property.
{
if (values[0].Equals(property.name))
{
return;
}
}
PropertyClass newProperty = new PropertyClass(); // Create a new Property class and set the values to the contents of the file.
newProperty.name = values[0];
newProperty.type = System.Convert.ToInt32(values[1]);
newProperty.value = SetValue(newProperty.type);
newProperty.description = values[2];
if (values.Length > 3)
{
newProperty.type += 5;
newProperty.minValue = System.Convert.ToInt32(values[3]);
newProperty.maxValue = System.Convert.ToInt32(values[4]);
}
list.Add(newProperty); // Add the new property to the list.
File.Create(PROPERTY_FILE_PATH); // Used to overwrite the property file so the data is not copied twice.
}
public void SetProperty_WhenSettingPropertyWithNonPublicAccessModifiers_ChangesPropertyValue()
{
var value = "test";
var testClass = new PropertyClass();
testClass.SetProperty(a => a.PrivateWritable, value);
Assert.AreEqual(value, testClass.PrivateWritable);
}
public void SetProperty_ChangesPropertyValue()
{
var value = "test";
var testClass = new PropertyClass();
testClass.SetProperty(a => a.Writable, value);
Assert.AreEqual(value, testClass.Writable);
}
public void TrySetProperty_ChangesPropertyValue()
{
var value = "test";
var testClass = new PropertyClass();
testClass.TrySetProperty(nameof(PropertyClass.Writable), value);
Assert.AreEqual(value, testClass.Writable);
}
public void Property()
{
var o = new PropertyClass();
o.Property = "bar";
var value = o.Property;
value.ShouldBe("barfoo");
}
private void LoadMsiDBProperty()
{
PropertyClass myProp = new PropertyClass();
CustomProperty myproperty = new CustomProperty("Installation Guid", misPackage.GetMsiProperty("ProductCode"), true, true);
myProp.Add(myproperty);
propertyGrid1.SelectedObject = myProp;
//LoadListView("Installation Guid", misPackage.GetMsiProperty("ProductCode"));
}
public void SetProperty_WhenPassingNullAsValueForNonNullableProperty_SetPropertyToDefaultValue()
{
var testClass = new PropertyClass()
{
NonNullableInt = 1
};
testClass.SetProperty(a => a.NonNullableInt, null);
Assert.AreEqual(default(int), testClass.NonNullableInt);
}
public static void Main()
{
int n;
PropertyClass obj = new PropertyClass();
obj.PrivateValue = 100; // invoke set-accessor
obj.PrintValue();
n = obj.PrivateValue; // invoke get-accessor
Console.WriteLine(" Value = " + n);
}
public void TestDumpClassPropertyClass()
{
var testClass = new PropertyClass()
{
x = 5, y = 7
};
Console.WriteLine(JSON.Dump(testClass, EncodeOptions.NoTypeHints));
Assert.AreEqual("{\"y\":7,\"p1\":1,\"p2\":2,\"p3\":3,\"p4\":4,\"p5\":5,\"p6\":6}", JSON.Dump(testClass, EncodeOptions.NoTypeHints));
}
public void GetPropertyTest()
{
PropertyClass propertyClass = new PropertyClass();
PropertyInfo actual = PropertyFinder <PropertyClass> .Find(x => x.GetMe);
PropertyInfo expected = propertyClass.GetType().GetProperty("GetMe");
Assert.AreEqual(expected, actual);
}
public override bool IsForThePointer(IObjectPointer pointer)
{
PropertyClass ic = pointer as PropertyClass;
if (ic != null)
{
return(ic.MemberId == this.PropertyId);
}
return(false);
}
public void GetInterfaceProperty()
{
var property = typeof(IPropertyClass).GetProperty("StringProperty");
var instance = new PropertyClass();
instance.StringProperty = "StringProperty";
var result = (string)property.GetValue(instance, null);
AssertEquals(result, "StringProperty");
}
public void SetProperty_ClassString_Blank()
{
var obj = new PropertyClass();
var stopwatch = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
obj.StringProperty = "";
}
stopwatch.StopAndLog(Iterations);
}
public PropertyItemClassPointer(string key, IClass owner, PropertyClass property)
: base(key, owner)
{
_property = (PropertyClass)property.Clone();
_property.SetHolder(owner);
_pointer = owner.VariableCustomType;
if (_pointer == null)
{
throw new DesignerException("null VariableCustomType creating PropertyItemClassPointer");
}
}
public void GetProperty_ClassString_Blank()
{
var obj = new PropertyClass();
var stopwatch = Stopwatch.StartNew();
for (var i = 0; i < Iterations; i++)
{
var prop = obj.StringProperty;
}
stopwatch.StopAndLog(Iterations);
}
private void LoadResourceProperties(string resource)
{
PropertyClass myProp = new PropertyClass();
foreach (var item in misPackage.GetResourceProperties(resource))
{
CustomProperty myproperty = new CustomProperty(item.Key, item.Value, true, true);
myProp.Add(myproperty);
}
propertyGrid1.SelectedObject = myProp;
}
private void btnOkClick(object sender, EventArgs e)
{
if (pc == null)
{
pc = new PropertyClass();
}
pc.PcCode = tbPCCode.Text;
pc.PcName = tbPCName.Text;
this.Tag = true;
this.Close();
}
