CustomProperty.cs 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306
  1. using Newtonsoft.Json;
  2. using System;
  3. using System.Linq;
  4. using System.Linq.Expressions;
  5. using System.Runtime.InteropServices;
  6. namespace InABox.Core
  7. {
  8. [UserTracking(typeof(User))]
  9. public class CustomProperty : Entity, IProperty, IPersistent, IRemotable, ISequenceable, ILicense<CoreLicense>
  10. {
  11. public Type? _class;
  12. private Func<object, object> _getter;
  13. private string _name = "";
  14. private Action<object, object?> _setter;
  15. private string _type;
  16. private Type type = typeof(object);
  17. private string _caption;
  18. private long _sequence;
  19. private string _page;
  20. private bool _visible;
  21. private bool _editable;
  22. protected override void Init()
  23. {
  24. base.Init();
  25. Visible = true;
  26. Editable = true;
  27. Required = false;
  28. HasEditor = true;
  29. Editor = new NullEditor();
  30. }
  31. [MemoEditor(Visible = Core.Visible.Default)]
  32. [EditorSequence(5)]
  33. public string Comment { get; set; }
  34. [CheckBoxEditor(Visible = Core.Visible.Default)]
  35. [EditorSequence(8)]
  36. public bool Visible
  37. {
  38. get => _visible;
  39. set
  40. {
  41. _visible = value;
  42. RegenerateEditor();
  43. }
  44. }
  45. [CheckBoxEditor(Visible = Core.Visible.Optional)]
  46. [EditorSequence(9)]
  47. public bool Editable
  48. {
  49. get => _editable;
  50. set
  51. {
  52. _editable = value;
  53. RegenerateEditor();
  54. }
  55. }
  56. [ComboLookupEditor(typeof(PropertyClassLookups))]
  57. [EditorSequence(1)]
  58. public string Class
  59. {
  60. get => _class != null ? _class.EntityName() : "";
  61. set
  62. {
  63. CoreUtils.TryGetEntity(value, out _class);
  64. CheckExpressions();
  65. }
  66. }
  67. [DoNotPersist]
  68. [DoNotSerialize]
  69. public Type? ClassType
  70. {
  71. get => _class;
  72. set
  73. {
  74. _class = value;
  75. CheckExpressions();
  76. }
  77. }
  78. [EditorSequence(2)]
  79. public string Name
  80. {
  81. get => _name;
  82. set
  83. {
  84. _name = value;
  85. CheckExpressions();
  86. RegenerateEditor();
  87. }
  88. }
  89. [ComboLookupEditor(typeof(PropertyTypeLookups), Visible = Core.Visible.Default)]
  90. [EditorSequence(3)]
  91. public string Type
  92. {
  93. get => _type;
  94. set
  95. {
  96. _type = value;
  97. try
  98. {
  99. type = CoreUtils.GetEntityOrNull(_type) ?? typeof(object);
  100. }
  101. catch
  102. {
  103. type = typeof(object);
  104. }
  105. CheckExpressions();
  106. IsEntityLink = type.GetInterfaces().Contains(typeof(IEntityLink));
  107. IsEnclosedEntity = type.GetInterfaces().Contains(typeof(IEnclosedEntity));
  108. RegenerateEditor();
  109. }
  110. }
  111. [DoNotPersist]
  112. [DoNotSerialize]
  113. public Type PropertyType
  114. {
  115. get => type;
  116. set
  117. {
  118. type = value;
  119. _type = value.EntityName();
  120. Editor = null;
  121. IsEntityLink = type.GetInterfaces().Contains(typeof(IEntityLink));
  122. IsEnclosedEntity = type.GetInterfaces().Contains(typeof(IEnclosedEntity));
  123. RegenerateEditor();
  124. }
  125. }
  126. [NullEditor]
  127. [DoNotPersist]
  128. [DoNotSerialize]
  129. public BaseEditor Editor { get; set; }
  130. [NullEditor]
  131. [DoNotPersist]
  132. [DoNotSerialize]
  133. public bool HasEditor { get; set; }
  134. [TextBoxEditor(Visible = Core.Visible.Optional)]
  135. [EditorSequence(6)]
  136. public string Caption
  137. {
  138. get => _caption;
  139. set
  140. {
  141. _caption = value;
  142. RegenerateEditor();
  143. }
  144. }
  145. [TextBoxEditor(Visible = Core.Visible.Optional)]
  146. [EditorSequence(7)]
  147. public string Page
  148. {
  149. get => _page;
  150. set
  151. {
  152. _page = value;
  153. RegenerateEditor();
  154. }
  155. }
  156. [CheckBoxEditor(Visible = Core.Visible.Optional)]
  157. [EditorSequence(8)]
  158. public bool Required { get; set; }
  159. [NullEditor]
  160. [EditorSequence(9)]
  161. public LoggablePropertyAttribute? Loggable { get; set; }
  162. [NullEditor]
  163. public long Sequence
  164. {
  165. get => _sequence;
  166. set
  167. {
  168. _sequence = value;
  169. RegenerateEditor();
  170. }
  171. }
  172. [NullEditor]
  173. [DoNotPersist]
  174. [DoNotSerialize]
  175. public IProperty? Parent { get; set; }
  176. [NullEditor]
  177. [DoNotPersist]
  178. [DoNotSerialize]
  179. public bool IsEntityLink { get; set; }
  180. [NullEditor]
  181. [DoNotPersist]
  182. [DoNotSerialize]
  183. public bool IsEnclosedEntity { get; set; }
  184. [NullEditor]
  185. [DoNotPersist]
  186. [DoNotSerialize]
  187. public bool IsCalculated => false;
  188. private static string? NonWhiteSpaceOrNull(string? name)
  189. {
  190. return string.IsNullOrWhiteSpace(name) ? null : name;
  191. }
  192. public TAttribute? GetAttribute<TAttribute>() where TAttribute : Attribute
  193. {
  194. return null;
  195. }
  196. private void RegenerateEditor()
  197. {
  198. Editor = EditorUtils.GetEditor(PropertyType) ?? new NullEditor();
  199. Editor.Caption = NonWhiteSpaceOrNull(Caption) ?? NonWhiteSpaceOrNull(Name) ?? "";
  200. Editor.EditorSequence = (int)Sequence;
  201. Editor.Page = Page;
  202. Editor.Editable = Editable ? Core.Editable.Enabled : Core.Editable.Disabled;
  203. Editor.Visible = Visible ? Core.Visible.Optional : Core.Visible.Hidden;
  204. }
  205. public Expression Expression()
  206. {
  207. if (_class is null)
  208. throw new Exception("No class for CustomProperty");
  209. return CoreUtils.CreateIndexExpression(_class, "UserProperties", Name);
  210. }
  211. public Func<object, object> Getter()
  212. {
  213. return _getter;
  214. }
  215. public Action<object, object?> Setter()
  216. {
  217. return _setter;
  218. }
  219. public override string ToString()
  220. {
  221. return string.Format("{0}.{1}", Class, Name);
  222. }
  223. private void CheckExpressions()
  224. {
  225. if (_class == null)
  226. return;
  227. if (string.IsNullOrEmpty(Name))
  228. return;
  229. try
  230. {
  231. _getter = Expressions.Getter(_class, "UserProperties", Name);
  232. _setter = Expressions.Setter(_class, "UserProperties", Name);
  233. }
  234. catch (Exception e)
  235. {
  236. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  237. }
  238. }
  239. public decimal PropertySequence() => Sequence;
  240. }
  241. public class CustomPropertyLookups : EntityLookup<CustomProperty>
  242. {
  243. public override Columns<CustomProperty> DefineColumns()
  244. {
  245. return base.DefineColumns()
  246. .Add(x => x.Class)
  247. .Add(x => x.Name);
  248. }
  249. //public string FormatLookup(Dictionary<string, object> values, IEnumerable<string> exclude)
  250. //{
  251. // return LookupFactory.DefaultFormatLookup(values, exclude.Concat(new String[] { "ID" }));
  252. //}
  253. public override Filter<CustomProperty>? DefineFilter()
  254. {
  255. return null;
  256. }
  257. public override SortOrder<CustomProperty> DefineSortOrder()
  258. {
  259. return new SortOrder<CustomProperty>(x => x.Class).ThenBy(x => x.Sequence);
  260. }
  261. }
  262. }