525 lines
16 KiB
C#
525 lines
16 KiB
C#
using CloudBuilder.Core.DependencyInjection.Form;
|
|
using CloudBuilder.Core.DependencyInjection.Request;
|
|
using CloudBuilder.Core.Service;
|
|
using CloudBuilder.Gui.DependencyInjection;
|
|
using CloudBuilder.Request.Security;
|
|
using CloudBuilder.Security.Entity;
|
|
using CloudBuilder.Security.Policy;
|
|
using CloudBuilder.Security.Utility;
|
|
using Krypton.Navigator;
|
|
using Krypton.Toolkit;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Resources;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
|
|
namespace CloudBuilder.Gui
|
|
{
|
|
public partial class AbstractForm : KryptonForm, IForm
|
|
{
|
|
private LoginContextPermission loginContextPermission;
|
|
private SecurityMessagePolicy securityMessagePolicy;
|
|
public string SecurityUserId = string.Empty;
|
|
public IContext Context;
|
|
//public WCFContract Wcf = null;
|
|
private object activatedParam;
|
|
public bool IsDialog = false;
|
|
public object OutputData = null;
|
|
public object InputData = null;
|
|
|
|
public string ParentFunctionId { get; set; }
|
|
public string FunctionId { get; set; }
|
|
public object ActivatedParam { get; set; }
|
|
|
|
protected GuiBindingContext guiBindingContext;
|
|
protected GuiOperateHelper guiOperateHelper = null;
|
|
|
|
public KryptonNavigator KryptonNavigator { get; set; }
|
|
public Dictionary<string, KryptonPage> PageContext = new Dictionary<string, KryptonPage>();
|
|
public GuiDisplayMode DisplayMode;
|
|
|
|
public AbstractForm()
|
|
{
|
|
InitializeComponent();
|
|
}
|
|
|
|
|
|
public AbstractForm(object param)
|
|
: this()
|
|
{
|
|
activatedParam = param;
|
|
}
|
|
|
|
public virtual void FunctionActivated(object param)
|
|
{
|
|
|
|
}
|
|
|
|
public virtual void FunctionLoaded()
|
|
{
|
|
DisplayMode = GuiDisplayMode.View;
|
|
|
|
InitResourceManager();
|
|
}
|
|
|
|
public string GetTitle(string functionName)
|
|
{
|
|
try
|
|
{
|
|
IContext loginContext = ServiceHelper.GetInterfaceService<IContext>()!;
|
|
SecurityFunctionRequest securityFunctionRequest = ServiceHelper.GetTypeService<SecurityFunctionRequest>();
|
|
SecurityFunctionEntity function = securityFunctionRequest.FindByFunctionName(functionName);
|
|
if (function == null) return null;
|
|
return loginContext.GetCulture() == LoginContext.CULTURE_EN ? function.FunctionEngName : function.FunctionLocalName;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ShowMessageBox.ShowInfo(ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public void InitResourceManager()
|
|
{
|
|
IContext loginContext = ServiceHelper.GetInterfaceService<IContext>()!;
|
|
string typeName = this.GetType().FullName + "_" + loginContext.GetCulture();
|
|
if (Assembly.GetAssembly(this.GetType()).GetManifestResourceNames().Contains(typeName + ".resources"))
|
|
{
|
|
ResourceManager rm = new ResourceManager(typeName, Assembly.GetAssembly(this.GetType()));
|
|
|
|
GuiOperateHelper.SetControlsText(this, rm);
|
|
}
|
|
}
|
|
|
|
public AbstractForm GetAbstractDialog(string functionViewId)
|
|
{
|
|
return GetAbstractDialog(functionViewId, null);
|
|
}
|
|
|
|
public AbstractForm GetAbstractDialog(string functionViewId, object param)
|
|
{
|
|
//if (ctx == null) ctx = ContextRegistry.GetContext();
|
|
|
|
//AbstractForm v = (AbstractForm)ctx.CreateObject(functionViewId, null, null);
|
|
AbstractForm v = new AbstractForm();
|
|
//v.Wcf = new WCFContract();
|
|
|
|
v.IsDialog = true;
|
|
|
|
v.FunctionId = functionViewId;
|
|
|
|
v.ActivatedParam = param;
|
|
|
|
v.FunctionLoaded();
|
|
|
|
v.FunctionActivated(param);
|
|
|
|
v.StartPosition = FormStartPosition.CenterScreen;
|
|
|
|
InitResourceManager();
|
|
|
|
return v;
|
|
}
|
|
|
|
public AbstractPage GetAbstractPage()
|
|
{
|
|
foreach (Control c in this.Controls)
|
|
{
|
|
if (c is AbstractPage)
|
|
{
|
|
return (AbstractPage)c;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public KryptonPage GetAbstractPage(ToolStripMenuItem sender)
|
|
{
|
|
KryptonPage af = GetAbstractPage(sender.Name);
|
|
af.Text = sender.Text;
|
|
|
|
return af;
|
|
}
|
|
|
|
public KryptonPage GetAbstractPage(string functionViewId)
|
|
{
|
|
return GetAbstractPage(functionViewId, null);
|
|
}
|
|
|
|
private KryptonPage GetAbstractPage(string functionViewId, object param)
|
|
{
|
|
loginContextPermission = new LoginContextPermission();
|
|
IContext loginContext = ServiceHelper.GetInterfaceService<IContext>()!;
|
|
if (!loginContext.Assert(loginContextPermission.AssertByFunctionName, functionViewId))
|
|
{
|
|
securityMessagePolicy = ServiceHelper.GetTypeService<SecurityMessagePolicy>()!;
|
|
throw new ValidationException(securityMessagePolicy.ComposeMessage("no_permission"));
|
|
}
|
|
|
|
KryptonPage v;
|
|
if (!PageContext.Keys.Contains(functionViewId))
|
|
{
|
|
v = new KryptonPage();
|
|
AbstractPage page = ServiceHelper.GetBaseTypeService<AbstractPage>(functionViewId);
|
|
page.Dock = DockStyle.Fill;
|
|
page.ActivatedParam = param;
|
|
page.InitResourceManager();
|
|
page.ParentKryptonPage = v;
|
|
page.ParentAbstractForm = this;
|
|
v.Controls.Add(page);
|
|
|
|
v.Text = GetTitle(functionViewId);
|
|
}
|
|
else
|
|
{
|
|
v = PageContext[functionViewId];
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
public KryptonPage GetInitPage(string functionViewId, KryptonNavigator kryptonNavigator, string title, object param)
|
|
{
|
|
KryptonPage v;
|
|
AbstractPage abstractPage = null; ;
|
|
if (!PageContext.Keys.Contains(functionViewId))
|
|
{
|
|
v = new KryptonPage();
|
|
abstractPage = ServiceHelper.GetBaseTypeService<AbstractPage>(functionViewId);
|
|
abstractPage.Dock = DockStyle.Fill;
|
|
abstractPage.ActivatedParam = param;
|
|
abstractPage.InitResourceManager();
|
|
abstractPage.ParentAbstractForm = this;
|
|
|
|
v.Controls.Add(abstractPage);
|
|
|
|
v.Text = title;
|
|
}
|
|
else
|
|
{
|
|
v = PageContext[functionViewId];
|
|
|
|
foreach (Control c in v.Controls)
|
|
{
|
|
if (c is AbstractPage)
|
|
{
|
|
abstractPage = (AbstractPage)c;
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
v.Text = title;
|
|
|
|
abstractPage.FunctionId = functionViewId;
|
|
|
|
abstractPage.KryptonNavigator = kryptonNavigator;
|
|
|
|
abstractPage.ActivatedParam = param;
|
|
|
|
abstractPage.FunctionLoaded();
|
|
|
|
abstractPage.FunctionActivated(param);
|
|
|
|
InitResourceManager();
|
|
|
|
return v;
|
|
}
|
|
|
|
public void DisplayAbstractPage(ToolStripMenuItem sender, KryptonNavigator kryptonNavigator)
|
|
{
|
|
DisplayAbstractPage(sender.Name, sender.Text, null, kryptonNavigator);
|
|
}
|
|
|
|
public void DisplayAbstractPage(string functionViewId)
|
|
{
|
|
DisplayAbstractPage(functionViewId, null);
|
|
}
|
|
|
|
public void DisplayAbstractPage(string functionViewId, string title, object param, KryptonNavigator kryptonNavigator)
|
|
{
|
|
//deselecting page1,selecting page 2,deselected page1,selected page2,selectedpagechanged page2
|
|
////如果没有权限返回
|
|
KryptonPage af = GetAbstractPage(functionViewId, param);
|
|
AbstractPage page = null;
|
|
foreach (Control c in af.Controls)
|
|
{
|
|
if (c is AbstractPage)
|
|
{
|
|
page = (AbstractPage)c;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(title))
|
|
{
|
|
af.Text = title;
|
|
}
|
|
else
|
|
{
|
|
af.Text = GetTitle(functionViewId);
|
|
}
|
|
|
|
if (!PageContext.Keys.Contains(functionViewId))
|
|
{
|
|
page.FunctionLoaded();
|
|
|
|
kryptonNavigator.Pages.Add(af);
|
|
|
|
PageContext.Add(functionViewId, af);
|
|
}
|
|
|
|
if (page == null) return;
|
|
|
|
page.KryptonNavigator = kryptonNavigator;
|
|
|
|
af.Visible = true;
|
|
kryptonNavigator.SelectedPage = af;
|
|
|
|
kryptonNavigator.Focus();
|
|
|
|
kryptonNavigator.SelectedPage.Focus();
|
|
|
|
page.FunctionActivated(param);
|
|
}
|
|
|
|
public void DisplayAbstractPage(string functionViewId, string title, object param)
|
|
{
|
|
DisplayAbstractPage(functionViewId, title, param, this.KryptonNavigator);
|
|
}
|
|
|
|
public void DisplayAbstractPage(string functionViewId, string title)
|
|
{
|
|
DisplayAbstractPage(functionViewId, title, null, this.KryptonNavigator);
|
|
}
|
|
|
|
public virtual KryptonNavigator GetKryptonNavigator()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public virtual void Print()
|
|
{
|
|
|
|
}
|
|
|
|
public static void SetMid(Form form)
|
|
{
|
|
// Center the Form on the user's screen everytime it requires a Layout.
|
|
form.SetBounds((Screen.GetBounds(form).Width / 2) - (form.Width / 2),
|
|
(Screen.GetBounds(form).Height / 2) - (form.Height / 2),
|
|
form.Width, form.Height, BoundsSpecified.Location);
|
|
}
|
|
|
|
public DialogResult ShowFormDialog()
|
|
{
|
|
return this.ShowFormDialog(null, false);
|
|
}
|
|
|
|
public DialogResult ShowFormDialog(string title)
|
|
{
|
|
return this.ShowFormDialog(title, false);
|
|
}
|
|
|
|
public DialogResult ShowFormDialog(string title, bool topMost)
|
|
{
|
|
IsDialog = true;
|
|
|
|
if (!string.IsNullOrEmpty(title))
|
|
this.Text = title;
|
|
|
|
this.TopMost = topMost;
|
|
|
|
this.ShowDialog();
|
|
|
|
return DialogResult;
|
|
}
|
|
public virtual DialogResult ShowDialog(object inputData)
|
|
{
|
|
return ShowDialog(null, inputData);
|
|
}
|
|
|
|
public virtual DialogResult ShowDialog(string title, object inputData)
|
|
{
|
|
this.InputData = inputData;
|
|
|
|
return this.ShowFormDialog(title);
|
|
}
|
|
|
|
public virtual DialogResult ShowViewDialog(object inputData)
|
|
{
|
|
return ShowViewDialog(null, inputData);
|
|
}
|
|
|
|
public virtual DialogResult ShowViewDialog(string title, object inputData)
|
|
{
|
|
this.InputData = inputData;
|
|
this.GetAbstractPage().InitInputData(inputData, GuiDisplayMode.View);
|
|
|
|
DialogResult dr = this.ShowFormDialog(title);
|
|
if (DialogResult.OK != dr) return dr;
|
|
if (this.OutputData == null)
|
|
this.OutputData = this.GetAbstractPage().GetOutputData();
|
|
|
|
return dr;
|
|
}
|
|
|
|
public virtual DialogResult ShowCreateDialog()
|
|
{
|
|
return ShowCreateDialog(null);
|
|
}
|
|
|
|
public virtual DialogResult ShowCreateDialog(string title)
|
|
{
|
|
this.GetAbstractPage().InitInputData(null, GuiDisplayMode.Create);
|
|
|
|
DialogResult dr = this.ShowFormDialog(title);
|
|
if (DialogResult.OK != dr) return dr;
|
|
|
|
if (this.OutputData == null)
|
|
this.OutputData = this.GetAbstractPage().GetOutputData();
|
|
|
|
return dr;
|
|
}
|
|
|
|
public virtual DialogResult ShowCreateDialog(string title, object inputData)
|
|
{
|
|
this.InputData = inputData;
|
|
|
|
this.GetAbstractPage().InitInputData(inputData, GuiDisplayMode.Create);
|
|
|
|
DialogResult dr = this.ShowFormDialog(title);
|
|
if (DialogResult.OK != dr) return dr;
|
|
|
|
if (this.OutputData == null)
|
|
this.OutputData = this.GetAbstractPage().GetOutputData();
|
|
|
|
return dr;
|
|
}
|
|
|
|
public virtual DialogResult ShowAmendDialog(object inputData)
|
|
{
|
|
return ShowAmendDialog(null, inputData);
|
|
}
|
|
|
|
public virtual DialogResult ShowAmendDialog(string title, object inputData)
|
|
{
|
|
this.InputData = inputData;
|
|
this.GetAbstractPage().InitInputData(inputData, GuiDisplayMode.Amend);
|
|
DialogResult dr = this.ShowFormDialog(title);
|
|
if (DialogResult.OK != dr) return dr;
|
|
|
|
if (this.OutputData == null)
|
|
this.OutputData = this.GetAbstractPage().GetOutputData();
|
|
|
|
return dr;
|
|
}
|
|
|
|
public new void Show()
|
|
{
|
|
Show(null);
|
|
}
|
|
|
|
public void Show(string title)
|
|
{
|
|
IsDialog = true;
|
|
|
|
this.Text = title;
|
|
|
|
this.ShowFormDialog();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 元参数传入HandleException(() => Save());
|
|
/// </summary>
|
|
/// <param name="action"></param>
|
|
public void HandleException(Action action)
|
|
{
|
|
try
|
|
{
|
|
action();
|
|
}
|
|
catch (ValidatedException ex)
|
|
{
|
|
ShowMessageBox.ShowInfo(ex.Message);
|
|
}
|
|
catch (ServiceErrorException ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 有参数传入
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="action"></param>
|
|
/// <param name="param"></param>
|
|
public void HandleException<T>(Action<T> action, T param)
|
|
{
|
|
try
|
|
{
|
|
action(param);
|
|
}
|
|
catch (ValidatedException ex)
|
|
{
|
|
ShowMessageBox.ShowInfo(ex.Message);
|
|
}
|
|
catch (ServiceErrorException ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 有参数传入，且有返回值
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <typeparam name="R"></typeparam>
|
|
/// <param name="action"></param>
|
|
/// <param name="param"></param>
|
|
/// <returns></returns>
|
|
public R HandleException<T, R>(Func<T, R> action, T param)
|
|
{
|
|
try
|
|
{
|
|
return action(param);
|
|
}
|
|
catch (ValidatedException ex)
|
|
{
|
|
ShowMessageBox.ShowInfo(ex.Message);
|
|
}
|
|
catch (ServiceErrorException ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
ShowMessageBox.ShowError(ex.Message);
|
|
}
|
|
|
|
return default(R)!;
|
|
}
|
|
}
|
|
}
|
|
|
|
|