Notes Issue

[shortsam1]

Trying to add the "Notes" section from the Northwind sample to my form,however I am getting an error that I cannot resolve.

I have the "Notes"Module under a st of Modules Called CORE and I am referencing this Notes module from another Module called Switch.

I receive the following error when trying to save a new record with a Note attached or trying to Edit a record without a note attached.

What am I missing or where am I going wrong?

Here is my code:

NoteRow.cs

using Serenity.ComponentModel;
using Serenity.Data;
using Serenity.Data.Mapping;
using System;
using System.ComponentModel;

namespace OnlineForms.Core.Entities
{
    [ConnectionKey("Default"), Module("Core"), TableName("Notes")]
    [DisplayName("Notes"), InstanceName("Note")]
    [ReadPermission("Administration:General")]
    [ModifyPermission("Administration:General")]
    public sealed class NoteRow : Row<NoteRow.RowFields>, IIdRow, INameRow, IInsertLogRow
    {
        [DisplayName("Note Id"), Identity, Column("NoteID"), IdProperty]
        public Int64? NoteId
        {
            get => fields.NoteId[this];
            set => fields.NoteId[this] = value;
        }

        [DisplayName("Entity Type"), Size(100), NotNull, Updatable(false), NameProperty]
        public String EntityType
        {
            get => fields.EntityType[this];
            set => fields.EntityType[this] = value;
        }

        [DisplayName("Entity Id"), Column("EntityID"), Size(100), NotNull, Updatable(false)]
        public Int64? EntityId
        {
            get => fields.EntityId[this];
            set => fields.EntityId[this] = value;
        }

        [DisplayName("Text"), NotNull, QuickSearch]
        public String Text
        {
            get => fields.Text[this];
            set => fields.Text[this] = value;
        }

        [DisplayName("Insert User Id"), NotNull, Insertable(false), Updatable(false)]
        public Int32? InsertUserId
        {
            get => fields.InsertUserId[this];
            set => fields.InsertUserId[this] = value;
        }

        [DisplayName("Insert User"), NotMapped]
        public String InsertUserDisplayName
        {
            get => fields.InsertUserDisplayName[this];
            set => fields.InsertUserDisplayName[this] = value;
        }

        [DisplayName("Insert Date"), NotNull, Insertable(false), Updatable(false)]
        public DateTime? InsertDate
        {
            get => fields.InsertDate[this];
            set => fields.InsertDate[this] = value;
        }
        public Field InsertUserIdField
        {
            get
            {
                return Fields.InsertUserId;
            }
        }

        public DateTimeField InsertDateField
        {
            get
            {
                return Fields.InsertDate;
            }
        }

        public NoteRow()
        {
        }

        public NoteRow(RowFields fields)
            : base(fields)
        {
        }

        public class RowFields : RowFieldsBase
        {
            public Int64Field NoteId;
            public StringField EntityType;
            public Int64Field EntityId;
            public StringField Text;
            public Int32Field InsertUserId;
            public DateTimeField InsertDate;
            public StringField InsertUserDisplayName;
        }
    }
}

NoteDialog.ts

namespace OnlineForms.Core {

    @Serenity.Decorators.registerClass()
    export class NoteDialog extends Serenity.TemplatedDialog<any> {

        private textEditor: Serenity.HtmlContentEditor;

        constructor() {
            super();

            this.textEditor = new Serenity.HtmlNoteContentEditor(this.byId('Text'));
        }

        protected getTemplate() {
            return (
                "<form id='~_Form' class='s-Form'>" +
                "<textarea id='~_Text' class='required'></textarea>" +
                "</form>");
        }

        protected getDialogOptions() {
            var opt = super.getDialogOptions();

            opt.buttons = [{
                text: Q.text('Dialogs.OkButton'),
                click: () => {
                    if (!this.validateForm()) {
                        return;
                    }

                    this.okClick && this.okClick();
                }
            }, {
                text: Q.text('Dialogs.CancelButton'),
                click: () => this.dialogClose()
            }
            ];

            return opt;
        }

        get text(): string {
            return this.textEditor.value;
        }

        set text(value: string) {
            this.textEditor.value = value;
        }

        public okClick: () => void;
    }
}

NoteRepositry.cs

using Serenity.Data;
using Serenity.Services;
using System.Data;
using MyRow = OnlineForms.Core.Entities.NoteRow;


namespace OnlineForms.Core.Repositories
{
    public class NoteRepository : BaseRepository
    {
        public NoteRepository(IRequestContext context)
             : base(context)
        {
        }

        private static MyRow.RowFields fld { get { return MyRow.Fields; } }

        public SaveResponse Create(IUnitOfWork uow, SaveRequest<MyRow> request)
        {
            return new MySaveHandler(Context).Process(uow, request, SaveRequestType.Create);
        }

        public SaveResponse Update(IUnitOfWork uow, SaveRequest<MyRow> request)
        {
            return new MySaveHandler(Context).Process(uow, request, SaveRequestType.Update);
        }

        public DeleteResponse Delete(IUnitOfWork uow, DeleteRequest request)
        {
            return new MyDeleteHandler(Context).Process(uow, request);
        }

        public RetrieveResponse<MyRow> Retrieve(IDbConnection connection, RetrieveRequest request)
        {
            return new MyRetrieveHandler(Context).Process(connection, request);
        }

        public ListResponse<MyRow> List(IDbConnection connection, ListRequest request)
        {
            return new MyListHandler(Context).Process(connection, request);
        }

        private class MySaveHandler : SaveRequestHandler<MyRow>
        {
            public MySaveHandler(IRequestContext context)
                 : base(context)
            {
            }
        }

        private class MyDeleteHandler : DeleteRequestHandler<MyRow>
        {
            public MyDeleteHandler(IRequestContext context)
                 : base(context)
            {
            }
        }

        private class MyRetrieveHandler : RetrieveRequestHandler<MyRow>
        {
            public MyRetrieveHandler(IRequestContext context)
                 : base(context)
            {
            }
        }

        private class MyListHandler : ListRequestHandler<MyRow>
        {
            public MyListHandler(IRequestContext context)
                 : base(context)
            {
            }
        }

    }
}

NotesEditor.ts

namespace OnlineForms.Core {

    @Serenity.Decorators.registerEditor([Serenity.IGetEditValue, Serenity.ISetEditValue])
    @Serenity.Decorators.element("<div/>")
    export class NotesEditor extends Serenity.TemplatedWidget<any>
        implements Serenity.IGetEditValue, Serenity.ISetEditValue {

        private isDirty: boolean;
        private items: NoteRow[];

        constructor(div: JQuery) {
            super(div);

            new Serenity.Toolbar(this.byId('Toolbar'), {
                buttons: [{
                    title: 'Add Note',
                    cssClass: 'add-button',
                    onClick: e => {
                        e.preventDefault();
                        this.addClick();
                    }
                }]
            });
        }

        protected getTemplate() {
            return "<div><div id='~_Toolbar'></div><ul id='~_NoteList'></ul></div>";
        }

        protected updateContent() {
            var noteList = this.byId('NoteList');
            noteList.children().remove();
            if (this.items) {
                var index = 0;
                for (var t1 = 0; t1 < this.items.length; t1++) {
                    var item = this.items[t1];
                    var li = $('<li/>');
                    $('<div/>').addClass('note-text').html(Q.coalesce(item.Text, '')).appendTo(li);

                    $('<a/>').attr('href', '#').addClass('note-date')
                        .text(item.InsertUserDisplayName + ' - ' +
                            Q.formatDate(item.InsertDate, 'g'))
                        .data('index', index).appendTo(li).click((e) => this.editClick(e));

                    $('<a/>').attr('href', '#').addClass('note-delete')
                        .attr('title', 'delete note').data('index', index)
                        .appendTo(li).click((e) => this.deleteClick(e));

                    li.appendTo(noteList);
                    index++;
                }
            }
        }

        protected addClick() {
            var dlg = new NoteDialog();
            dlg.dialogTitle = 'Add Note';
            dlg.okClick = () => {
                var text = Q.trimToNull(dlg.text);
                if (text == null) {
                    return;
                }

                this.items = this.items || [];
                Q.insert(this.items, 0, {
                    Text: text,
                    InsertUserDisplayName: Authorization.userDefinition.DisplayName,
                    InsertDate: Q.formatISODateTimeUTC(new Date())
                });

                this.updateContent();
                dlg.dialogClose();
                this.set_isDirty(true);
                this.onChange && this.onChange();
            };
            dlg.dialogOpen();
        }

        protected editClick(e) {
            e.preventDefault();
            var index = $(e.target).data('index');
            var old = this.items[index];
            var dlg = new NoteDialog();
            dlg.dialogTitle = 'Edit Note';
            dlg.text = old.Text;
            dlg.okClick = () => {
                var text = Q.trimToNull(dlg.text);
                if (!text) {
                    return;
                }

                this.items[index].Text = text;
                this.updateContent();
                dlg.dialogClose();
                this.set_isDirty(true);
                this.onChange && this.onChange();
            };
            dlg.dialogOpen();
        }

        public deleteClick(e) {
            e.preventDefault();
            var index = $(e.target).data('index');
            Q.confirm('Delete this note?', () => {
                this.items.splice(index, 1);
                this.updateContent();
                this.set_isDirty(true);
                this.onChange && this.onChange();
            });
        }

        public get value() {
            return this.items;
        }

        public set value(value: NoteRow[]) {
            this.items = value || [];
            this.set_isDirty(false);
            this.updateContent();
        }

        public getEditValue(prop: Serenity.PropertyItem, target) {
            target[prop.name] = this.value;
        }

        public setEditValue(source, prop: Serenity.PropertyItem) {
            this.value = source[prop.name] || [];
        }

        public get_isDirty(): boolean {
            return this.isDirty;
        }

        public set_isDirty(value): void {
            this.isDirty = value;
        }

        public onChange: () => void;
    }
}

NotesBehavior.cs

using OnlineForms.Administration.Entities;
using OnlineForms.Core.Entities;
using OnlineForms.Core.Repositories;
using Serenity;
using Serenity.Data;
using Serenity.Services;
using System;
using System.Collections.Generic;
using System.Linq;

namespace OnlineForms.Core
{
    public class NotesBehavior : BaseSaveDeleteBehavior, IImplicitBehavior, IRetrieveBehavior, IFieldBehavior
    {
        public IRequestContext Context { get; }
        public ISqlConnections SqlConnections { get; }

        public NotesBehavior(IRequestContext context, ISqlConnections sqlConnections)
        {
            Context = context ?? throw new ArgumentNullException(nameof(context));
            SqlConnections = sqlConnections ?? throw new ArgumentNullException(nameof(sqlConnections));
        }

        public Field Target { get; set; }

        public bool ActivateFor(IRow row)
        {
            if (ReferenceEquals(null, Target))
                return false;

            var attr = Target.GetAttribute<NotesEditorAttribute>();
            if (attr == null)
                return false;

            if (Target.ValueType != typeof(List<NoteRow>))
            {
                throw new ArgumentException(String.Format("Field '{0}' in row type '{1}' has a NotesEditorAttribute " +
                    "but its property type is not a List<NoteRow>!",
                    Target.PropertyName ?? Target.Name, row.GetType().FullName));
            }

            return true;
        }

        public void OnAfterExecuteQuery(IRetrieveRequestHandler handler) { }
        public void OnBeforeExecuteQuery(IRetrieveRequestHandler handler) { }
        public void OnPrepareQuery(IRetrieveRequestHandler handler, SqlQuery query) { }
        public void OnValidateRequest(IRetrieveRequestHandler handler) { }

        public void OnReturn(IRetrieveRequestHandler handler)
        {
            if (ReferenceEquals(null, Target) ||
                !handler.AllowSelectField(Target) ||
                !handler.ShouldSelectField(Target))
                return;

            var idField = (handler.Row as IIdRow).IdField;
            var fld = NoteRow.Fields;

            var listRequest = new ListRequest
            {
                ColumnSelection = ColumnSelection.List,
                EqualityFilter = new Dictionary<string, object>
                {
                    { fld.EntityType.PropertyName, handler.Row.Table },
                    { fld.EntityId.PropertyName, idField.AsObject(handler.Row)?? -1 }
                }
            };

            var notes = new NoteRepository(Context).List(handler.Connection, listRequest).Entities;

            // users might be in another database, in another db server, so we can't simply use a join here
            var userIdList = notes.Where(x => x.InsertUserId != null).Select(x => x.InsertUserId.Value).Distinct();
            if (userIdList.Any())
            {
                var u = UserRow.Fields;
                IDictionary<int, string> userDisplayNames;
                using (var connection = SqlConnections.NewFor<UserRow>())
                    userDisplayNames = connection.Query(new SqlQuery()
                            .From(u)
                            .Select(u.UserId)
                            .Select(u.DisplayName)
                            .Where(u.UserId.In(userIdList)))
                        .ToDictionary(x => (int)(x.UserId ?? x.USERID), x => (string)x.DisplayName);

                string s;
                foreach (var x in notes)
                    if (x.InsertUserId != null && userDisplayNames.TryGetValue(x.InsertUserId.Value, out s))
                        x.InsertUserDisplayName = s;
            }

            Target.AsObject(handler.Row, notes);
        }

        private void SaveNote(IUnitOfWork uow, NoteRow note, string entityType, Int64 entityId, Int64? noteId)
        {
            note = note.Clone();
            note.NoteId = noteId;
            note.EntityType = entityType;
            note.EntityId = entityId;
            note.InsertDate = null;
            note.ClearAssignment(NoteRow.Fields.InsertDate);

            var saveRequest = new SaveRequest<NoteRow> { Entity = note };

            if (noteId == null)
                new NoteRepository(Context).Create(uow, saveRequest);
            else
                new NoteRepository(Context).Update(uow, saveRequest);
        }

        private void DeleteNote(IUnitOfWork uow, Int64 noteId)
        {
            new NoteRepository(Context).Delete(uow, new DeleteRequest { EntityId = noteId });
        }

        private void NoteListSave(IUnitOfWork uow, string entityType, Int64 entityId, List<NoteRow> oldList, List<NoteRow> newList)
        {
            var row = oldList.Count > 0 ? oldList[0] :
                (newList.Count > 0) ? newList[0] : null;

            if (row == null)
                return;

            if (oldList.Count == 0)
            {
                foreach (var note in newList)
                    SaveNote(uow, note, entityType, entityId, null);

                return;
            }

            var rowIdField = (row as IIdRow).IdField;

            if (newList.Count == 0)
            {
                foreach (var note in oldList)
                    DeleteNote(uow, Convert.ToInt64(rowIdField.AsObject(note)));

                return;
            }

            var oldById = new Dictionary<Int64, NoteRow>(oldList.Count);
            foreach (var item in oldList)
                oldById[Convert.ToInt64(rowIdField.AsObject(item))] = item;

            var newById = new Dictionary<Int64, NoteRow>(newList.Count);
            foreach (var item in newList)
            {
                var id = rowIdField.AsObject(item);
                if (id != null)
                    newById[Convert.ToInt64(id)] = item;
            }

            foreach (var item in oldList)
            {
                var id = Convert.ToInt64(rowIdField.AsObject(item));
                if (!newById.ContainsKey(id))
                    DeleteNote(uow, id);
            }

            foreach (var item in newList)
            {
                var id = rowIdField.AsObject(item);

                NoteRow old;
                if (id == null || !oldById.TryGetValue(Convert.ToInt64(id), out old))
                    continue;

                bool anyChanges = false;
                foreach (var field in item.GetFields())
                {
                    if (item.IsAssigned(field) &&
                        (field.Flags & FieldFlags.Updatable) == FieldFlags.Updatable &
                        field.IndexCompare(old, item) != 0)
                    {
                        anyChanges = true;
                        break;
                    }
                }

                if (!anyChanges)
                    continue;

                SaveNote(uow, item, entityType, entityId, Convert.ToInt64(id));
            }

            foreach (var item in newList)
            {
                var id = rowIdField.AsObject(item);
                if (id == null || !oldById.ContainsKey(Convert.ToInt64(id)))
                    SaveNote(uow, item, entityType, entityId, null);
            }
        }

        public override void OnAfterSave(ISaveRequestHandler handler)
        {
            var newList = Target.AsObject(handler.Row) as List<NoteRow>;
            if (newList == null)
                return;

            var idField = (handler.Row as IIdRow).IdField;
            var entityId = Convert.ToInt64(idField.AsObject(handler.Row));

            if (handler.IsCreate)
            {
                foreach (var note in newList)
                    SaveNote(handler.UnitOfWork, note, handler.Row.Table, entityId, null);

                return;
            }

            var fld = NoteRow.Fields;
            var listRequest = new ListRequest
            {
                ColumnSelection = ColumnSelection.List,
                EqualityFilter = new Dictionary<string, object>
                {
                    { fld.EntityType.PropertyName, handler.Row.Table },
                    { fld.EntityId.PropertyName, entityId }
                }
            };

            var oldList = new NoteRepository(Context).List(handler.Connection, listRequest).Entities;
            NoteListSave(handler.UnitOfWork, handler.Row.Table, entityId, oldList, newList);
        }

        public override void OnBeforeDelete(IDeleteRequestHandler handler)
        {
            if (ReferenceEquals(null, Target) ||
                (Target.Flags & FieldFlags.Updatable) != FieldFlags.Updatable)
                return;

            var idField = (handler.Row as IIdRow).IdField;
            var row = new NoteRow();
            var fld = NoteRow.Fields;

            var deleteList = new List<Int64>();
            new SqlQuery()
                    .From(row)
                    .Select(fld.NoteId)
                    .Where(
                        fld.EntityType == handler.Row.Table &
                        fld.EntityId == Convert.ToInt64(idField.AsObject(handler.Row)))
                    .ForEach(handler.Connection, () =>
                    {
                        deleteList.Add(row.NoteId.Value);
                    });

            foreach (var id in deleteList)
                DeleteNote(handler.UnitOfWork, id);
        }
    }
}

In my SwitchRow.cs I have:

       [NotesEditor, NotMapped, DisplayName("Note")]
        public List<NoteRow> NoteList
        {
            get => fields.NoteList[this];
            set => fields.NoteList[this] = value;
        }

       public class RowFields : LoggingRowFields
        {
            public RowListField<NoteRow> NoteList;
 }

In my switchForm.cs I have:

       [NotesEditor]
        public List<object> NoteList { get; set; }

In my SwitchDialog.ts I have:

        constructor() {
            super();

            this.byId('NoteList').closest('.field').hide().end().appendTo(this.byId('TabNotes'));
            DialogUtils.pendingChangesConfirmation(this.element, () => this.getSaveState() != this.loadedState);

        }

[shortsam1]

I found the answer. I had to change my table name to
"[online_forms].[notes]"

This is solved