CustomProperty.cs 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  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. [EditorSequence(2)]
  68. public string Name
  69. {
  70. get => _name;
  71. set
  72. {
  73. _name = value;
  74. CheckExpressions();
  75. RegenerateEditor();
  76. }
  77. }
  78. [ComboLookupEditor(typeof(PropertyTypeLookups), Visible = Core.Visible.Default)]
  79. [EditorSequence(3)]
  80. public string Type
  81. {
  82. get => _type;
  83. set
  84. {
  85. _type = value;
  86. try
  87. {
  88. type = CoreUtils.GetEntityOrNull(_type) ?? typeof(object);
  89. }
  90. catch
  91. {
  92. type = typeof(object);
  93. }
  94. IsEntityLink = type.GetInterfaces().Contains(typeof(IEntityLink));
  95. RegenerateEditor();
  96. }
  97. }
  98. [DoNotPersist]
  99. [DoNotSerialize]
  100. public Type PropertyType
  101. {
  102. get => type;
  103. set
  104. {
  105. type = value;
  106. _type = value.EntityName();
  107. Editor = null;
  108. IsEntityLink = type.GetInterfaces().Contains(typeof(IEntityLink));
  109. RegenerateEditor();
  110. }
  111. }
  112. [NullEditor]
  113. [DoNotPersist]
  114. [DoNotSerialize]
  115. public BaseEditor Editor { get; set; }
  116. [NullEditor]
  117. [DoNotPersist]
  118. [DoNotSerialize]
  119. public bool HasEditor { get; set; }
  120. [TextBoxEditor(Visible = Core.Visible.Optional)]
  121. [EditorSequence(6)]
  122. public string Caption
  123. {
  124. get => _caption;
  125. set
  126. {
  127. _caption = value;
  128. RegenerateEditor();
  129. }
  130. }
  131. [TextBoxEditor(Visible = Core.Visible.Optional)]
  132. [EditorSequence(7)]
  133. public string Page
  134. {
  135. get => _page;
  136. set
  137. {
  138. _page = value;
  139. RegenerateEditor();
  140. }
  141. }
  142. [CheckBoxEditor(Visible = Core.Visible.Optional)]
  143. [EditorSequence(8)]
  144. public bool Required { get; set; }
  145. [NullEditor]
  146. [EditorSequence(9)]
  147. public LoggablePropertyAttribute? Loggable { get; set; }
  148. [NullEditor]
  149. public long Sequence
  150. {
  151. get => _sequence;
  152. set
  153. {
  154. _sequence = value;
  155. RegenerateEditor();
  156. }
  157. }
  158. [NullEditor]
  159. [DoNotPersist]
  160. [DoNotSerialize]
  161. public IProperty? Parent { get; set; }
  162. [NullEditor]
  163. [DoNotPersist]
  164. [DoNotSerialize]
  165. public bool IsEntityLink { get; set; }
  166. private static string? NonWhiteSpaceOrNull(string? name)
  167. {
  168. return string.IsNullOrWhiteSpace(name) ? null : name;
  169. }
  170. private void RegenerateEditor()
  171. {
  172. Editor = EditorUtils.GetEditor(PropertyType) ?? new NullEditor();
  173. Editor.Caption = NonWhiteSpaceOrNull(Caption) ?? NonWhiteSpaceOrNull(Name) ?? "";
  174. Editor.EditorSequence = (int)Sequence;
  175. Editor.Page = Page;
  176. Editor.Editable = Editable ? Core.Editable.Enabled : Core.Editable.Disabled;
  177. Editor.Visible = Visible ? Core.Visible.Optional : Core.Visible.Hidden;
  178. }
  179. public Expression Expression()
  180. {
  181. if (_class is null)
  182. throw new Exception("No class for CustomProperty");
  183. return CoreUtils.CreateIndexExpression(_class, "UserProperties", Name);
  184. }
  185. public Func<object, object> Getter()
  186. {
  187. return _getter;
  188. }
  189. public Action<object, object> Setter()
  190. {
  191. return _setter;
  192. }
  193. public override string ToString()
  194. {
  195. return string.Format("{0}.{1}", Class, Name);
  196. }
  197. private void CheckExpressions()
  198. {
  199. if (_class == null)
  200. return;
  201. if (string.IsNullOrEmpty(Name))
  202. return;
  203. try
  204. {
  205. _getter = Expressions.Getter(_class, "UserProperties", Name);
  206. _setter = Expressions.Setter(_class, "UserProperties", Name);
  207. }
  208. catch (Exception e)
  209. {
  210. Logger.Send(LogType.Error, "", string.Format("*** Unknown Error: {0}\n{1}", e.Message, e.StackTrace));
  211. }
  212. }
  213. }
  214. public class CustomPropertyLookups : EntityLookup<CustomProperty>
  215. {
  216. public override Columns<CustomProperty> DefineColumns()
  217. {
  218. return base.DefineColumns()
  219. .Add(x => x.Class)
  220. .Add(x => x.Name);
  221. }
  222. //public string FormatLookup(Dictionary<string, object> values, IEnumerable<string> exclude)
  223. //{
  224. // return LookupFactory.DefaultFormatLookup(values, exclude.Concat(new String[] { "ID" }));
  225. //}
  226. public override Filter<CustomProperty>? DefineFilter()
  227. {
  228. return null;
  229. }
  230. public override SortOrder<CustomProperty> DefineSortOrder()
  231. {
  232. return new SortOrder<CustomProperty>(x => x.Class).ThenBy(x => x.Sequence);
  233. }
  234. }
  235. }