Exemple #1
0
        protected virtual async Task OnValidAsync(EditContext editContext)
        {
            Processing = true;
            await InvokeAsync(() => StateHasChanged());
            await CloseEditDialog();

            try
            {
                if (Mode == EditMode.CreateNew)
                {
                    try
                    {
                        EdittingModel.CreateNew(DB.Context, Config);
                    }
                    catch (Exception e)
                    {
                        ErrorSubject = e.Message;
                        ErrorMessage = e.StackTrace;
                    }
                    DB.Context.SaveChanges();
                    OnAfterCreateAndCloseDialog(EdittingModel);
                    await OnAfterCreateAsync(EdittingModel);
                }
                if (Mode == EditMode.Edit)
                {
                    var previous = EdittingModel.GetEntityAsNoTracking(DB.Context, Config);
                    try
                    {
                        EdittingModel.Update(DB.Context, Config, previous);
                    }
                    catch (Exception e)
                    {
                        ErrorSubject = e.Message;
                        ErrorMessage = e.StackTrace;
                    }
                    DB.Context.SaveChanges();
                    OnAfterUpdateAndCloseDialog(EdittingModel);
                    await OnAfterUpdateAsync(EdittingModel);
                }
                await InvokeAsync(() => StateHasChanged());
                await InvokeAsync(() => Notifier.Update());

                Processing = false;
            }
            catch (Exception e)
            {
                ErrorMessage = e.Message;
                Processing   = false;
                Console.Error.WriteLine(e);
                await CloseEditDialog();

                return;
            }
        }
Exemple #2
0
        protected async Task Submit()
        {
            var v1 = EditContext.Validate();
            var v2 = Mode == EditMode.CreateNew
                ? EdittingModel.ServerSideValidationOnCreate(DB.Context, Config, AddValidationError)
                : EdittingModel.ServerSideValidationOnUpdate(DB.Context, Config, AddValidationError);

            if (v1 && v2)
            {
                await OnValidAsync(EditContext);
            }
        }
Exemple #3
0
 protected async Task OpenCreate(T template = null)
 {
     if (!Permision.HasFlag(EntityManagementPermision.CanCreateNew))
     {
         ErrorSubject = "Permission Error";
         ErrorMessage = "You can not create new entity.";
         return;
     }
     EdittingModel = template == null ? new T() : template;
     SetSomeParameterToModel(EdittingModel);
     EdittingModel.PrepareModelForAddNew(DB.Context, Config);
     Mode = EditMode.CreateNew;
     ResetEdittingModel();
     await OpenEditDialog();
 }
Exemple #4
0
 protected async Task OpenEdit(T beforeModel)
 {
     if (!Permision.HasFlag(EntityManagementPermision.CanEdit))
     {
         ErrorSubject = "Permission Error";
         ErrorMessage = "You can not edit entity.";
         return;
     }
     BeforeModel   = beforeModel;
     EdittingModel = beforeModel.GetEntityForEditOrRemove(DB.Context, Config);
     if (EdittingModel == null)
     {
         ErrorSubject = "Error";
         ErrorMessage = "Not found the entity";
         return;
     }
     SetSomeParameterToModel(EdittingModel);
     EdittingModel.PrepareModelForEdit(DB.Context, Config, beforeModel);
     Mode = EditMode.Edit;
     ResetEdittingModel(EdittingModel);
     await OpenEditDialog();
 }