protected override void Submit(SubmitArgs e)
{
var entity = e.Entity as FileInfo;
switch (e.Action)
{
case SubmitAction.Delete:
FileStoragePlugin.ContentProvider.DeleteContent(entity);
break;
case SubmitAction.ChildrenOnly:
case SubmitAction.Insert:
case SubmitAction.Update:
if (entity.FieldExists(FileInfo.ContentProperty))
{
FileStoragePlugin.ContentProvider.SaveContent(entity, entity.Content);
}
break;
default:
break;
}
base.Submit(e);
}
private void ResetStamp(SubmitArgs e)
{
switch (e.Action)
{
case SubmitAction.ChildrenOnly:
case SubmitAction.Update:
var entity = e.Entity;
entity.SetUpdatedTime(DateTime.Now);
var user = RafyEnvironment.Identity;
if (user.IsAuthenticated)
{
entity.SetUpdatedUser(user.Name);
}
break;
case SubmitAction.Insert:
var entity2 = e.Entity;
var now = DateTime.Now;
entity2.SetUpdatedTime(now);
entity2.SetCreatedTime(now);
var user2 = RafyEnvironment.Identity;
if (user2.IsAuthenticated)
{
entity2.SetUpdatedUser(user2.Name);
entity2.SetCreatedUser(user2.Name);
}
break;
default:
//do nothing;
break;
}
}
/// <summary>
/// 提交指定的实体，并在添加、更新实体时，设置实体的跟踪戳。
/// </summary>
/// <param name="e">The e.</param>
/// <param name="link">The link.</param>
protected override void Submit(SubmitArgs e, ISubmitInterceptorLink link)
{
switch (e.Action)
{
case SubmitAction.ChildrenOnly:
case SubmitAction.Update:
var entity = e.Entity;
entity.SetUpdatedTime(DateTime.Now);
var user = RafyEnvironment.Identity;
if (user.IsAuthenticated)
{
entity.SetUpdatedUser(user.Name);
}
break;
case SubmitAction.Insert:
var entity2 = e.Entity;
var now = DateTime.Now;
entity2.SetUpdatedTime(now);
entity2.SetCreatedTime(now);
var user2 = RafyEnvironment.Identity;
if (user2.IsAuthenticated)
{
entity2.SetUpdatedUser(user2.Name);
entity2.SetCreatedUser(user2.Name);
}
break;
default:
//do nothing;
break;
}
link.InvokeNext(this, e);
}
protected override void Submit(SubmitArgs e)
{
//把Value更新为服务端时间，再保存到库中。
(e.Entity as ScopeVersion).Value = DateTime.Now;
base.Submit(e);
}
/// <summary>
/// 提交指定的实体，并在添加、更新实体时，设置实体的跟踪戳。
/// </summary>
/// <param name="e">The e.</param>
/// <param name="link">The link.</param>
protected override void Submit(SubmitArgs e, ISubmitInterceptorLink link)
{
bool disabled = false;
if (StampContext.Disabled)
{
if (StampContext.ThreadId == Thread.CurrentThread.ManagedThreadId)
{
//如果是 Disable 的线程，则忽略
disabled = true;
}
else
{
//如果不是 Disable 的线程，则需要等待 Disable 的线程结束后，才能继续执行后续的操作。
lock (StampContext.DisabledLock) { }
}
}
if (!disabled)
{
this.ResetStamp(e);
}
link.InvokeNext(this, e);
}
public HttpWebResponse GetResponse()
{
var args = new SubmitArgs()
{
FollowRedirect = true
};
BeforeSubmit?.Invoke(this, args);
HttpWebResponse resp;
bool redirect;
do
{
var request = (HttpWebRequest)WebRequest.Create(Uri);
request.Method = Method.Method;
request.Proxy = Proxy;
request.AllowAutoRedirect = false;
request.Headers = Headers;
resp = (HttpWebResponse)request.GetResponse();
var status = (int)resp.StatusCode;
var location = resp.Headers["Location"];
redirect = status >= 300 && status < 400 && location != null;
if (redirect)
{
resp.Close();
Uri = new Uri(location);
BeforeSubmit?.Invoke(this, args);
}
} while (redirect && args.FollowRedirect);
return(resp);
}
protected override void Submit(SubmitArgs e)
{
if (UpdateCurrent && e.Action == SubmitAction.ChildrenOnly)
{
e.UpdateCurrent();
}
base.Submit(e);
}
protected override void Submit(SubmitArgs e)
{
base.Submit(e);
if (e.Action == SubmitAction.Delete)
{
//由于本外键关系没有级联，所以在删除的时候需要删除下面的数据
this.DeleteRef(e.Entity, StorageOutBillItem.StorageOutBillProperty);
}
}
protected override void Submit(SubmitArgs e)
{
if (e.Action == SubmitAction.Delete)
{
//在删除前需要删除所有语言中的映射项。
this.DeleteRefInDb(e.Entity, MappingInfo.DevLanguageItemProperty);
}
base.Submit(e);
}
protected override void Submit(SubmitArgs e)
{
if (e.Action == SubmitAction.Update || e.Action == SubmitAction.ChildrenOnly)
{
(e.Entity as ViewConfigurationModel).SaveToXml();
}
else
{
base.Submit(e);
}
}
protected override void Submit(SubmitArgs e)
{
if (e.Action == SubmitAction.Delete)
{
var entity = e.Entity as ClientCategory;
if (entity.Name == ClientCategory.SupplierName || entity.Name == ClientCategory.CustomerName)
{
throw new InvalidOperationException("不能删除系统内置的客户类型：" + entity.Name);
}
}
base.Submit(e);
}
protected override void Submit(SubmitArgs e)
{
if (TestSaveListTransactionItemCount >= 0)
{
TestSaveListTransactionItemCount++;
if (TestSaveListTransactionItemCount > 1)
{
throw new NotSupportedException("超过一条数据，直接抛出异常。之前的数据需要回滚。");
}
}
base.Submit(e);
}
protected override void Submit(SubmitArgs e)
{
if (e.Action != SubmitAction.Delete)
{
(e.Entity as FileAttachement).SaveToDisk();
}
base.Submit(e);
if (e.Action == SubmitAction.Delete)
{
(e.Entity as FileAttachement).DeleteFromDisk();
}
}
protected override void Submit(SubmitArgs e)
{
if (e.Action != SubmitAction.Delete)
{
(e.Entity as MemoryCustomer).Version++;
}
base.Submit(e);
if (e.Action == SubmitAction.Delete)
{
var item = e.Entity as MemoryCustomer;
item.LoadProperty(MemoryCustomer.VersionProperty, item.Version + 1);
}
}
// catch sumit event and send it to observers
protected void SubmitRequest(object o, SubmitArgs args)
{
OnSubmit(o, args);
}
/// <summary>
/// 提交聚合对象到数据库中。
///
/// 子类重写此方法实现整个聚合对象保存到非关系型数据库的逻辑。
/// 如果只想重写单个对象的 CUD 逻辑，请重写 Insert、Update、Delete 方法。
///
/// 注意，不论是聚合父对象，还是聚合子对象，还是没有聚合子的对象，都会执行该方法。
/// 它与 Insert、Update、Delete 等方法的区别在于，重写此方法可以同时阻止对聚合子对象的默认保存逻辑。
/// </summary>
/// <param name="e"></param>
protected internal virtual void Submit(SubmitArgs e)
{
var entity = e.Entity;
switch (e.Action)
{
case SubmitAction.Delete:
this.DoDelete(entity);
break;
case SubmitAction.Insert:
this.DoInsert(entity, e.WithTreeChildren);
break;
case SubmitAction.Update:
this.DoUpdate(entity, e.WithTreeChildren);
break;
case SubmitAction.ChildrenOnly:
this.SubmitChildren(entity);
if (e.WithTreeChildren && _repository.SupportTree)
{
this.SubmitTreeChildren(entity);
}
break;
default:
throw new NotSupportedException();
}
}
protected internal override void Submit(SubmitArgs e)
{
_dp.EnsureStore();
base.Submit(e);
}
internal protected override void Submit(SubmitArgs e)
{
_dp.EnsureStore();
base.Submit(e);
}
/// <summary>
/// 根据实体状态来选择保存方法。
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="markSaved">是否当前正在保存最外层组合根对象。如果是，则应该在保存完成后，把整个组合对象状态清空。</param>
/// <param name="withTreeChildren">是否需要同时处理树的子节点。</param>
/// <exception cref="System.NotSupportedException"></exception>
private void SubmitItem(Entity entity, bool markSaved, bool withTreeChildren)
{
//创建提交数据的参数。
var args = new SubmitArgs
{
Entity = entity,
WithTreeChildren = withTreeChildren,
Action = GetAction(entity)
};
//提交更改。
_dataProvider.Submit(args);
//保存完毕，修改实体的状态
switch (args.Action)
{
case SubmitAction.Delete:
//在删除后，标记对象的状态到“新对象”。
entity.PersistenceStatus = PersistenceStatus.New;
break;
case SubmitAction.Update:
case SubmitAction.Insert:
case SubmitAction.ChildrenOnly:
if (markSaved)
{
entity.MarkSaved();
}
break;
default:
throw new NotSupportedException();
}
}
// handler for submiting htmlWidget
public void htmlWidget_submit(object o, SubmitArgs args)
{
// prepare parameters
// if at least one parameter exists, trim preambule
string paramLine = (args.Encoding.Length > 8 ? args.Encoding.Substring(8) : "");
string[] parametry = paramLine.Split('&');
ArrayList parameters = new ArrayList(parametry.Length);
foreach (string param in parametry)
{
// combobox has '+' at the end of selected value, so remove it
string[] parameter = param.Trim('+').Split('=');
if (parameter.Length >= 2)
// if there is no parameter, array have only one (empty) item, so do not add it
parameters.Add(new BString(parameter[0], parameter[1]));
}
// execute procedure
TreeIter iter;
TreeModel model;
string oid;
if (treeview2.Selection.GetSelected(out model, out iter))
{
oid = (string) model.GetValue (iter, 1);
// tree roots can't be run
if (oid == "BelineInf" || oid == "BelineBench" || oid == "BelineSet") return;
BMasterServiceManager manager = BMasterServiceManager.GetInstance();
string transaction = null;
try
{
transaction = manager.StartModule(oid);
}
catch (Exception e)
{
Simple.ErrorAlert("Nepodařilo se inicializovat modul", e.Message, this);
return;
}
try
{
manager.RunModule(transaction, "Default", parameters);
BMessageReturn message = manager.ReceiveMessage(true) as BMessageReturn;
if (message == null) throw new Exception("Module doesn't communicate.");
XmlDocument hodnota = new XmlDocument();
string hodnotaHtml;
try
{
hodnota.LoadXml(message.Result);
hodnotaHtml = Beline.Tools.XslTransform.Transform(hodnota, "beline.html.xslt");
}
catch (XmlException e)
{
hodnotaHtml = "<html> <body><div align=center style=\"color:red;\"><b>Error!</b></div></body> </html>";
}
//Console.WriteLine(hodnotaHtml);
htmlRender.Render(hodnotaHtml);
//htmlWidget.ImagesRef();
}
catch (Exception e)
{
Simple.ErrorAlert("Nepodařilo se spustit modul", e.Message, this);
return;
}
try
{
manager.StopModule(transaction);
}
catch (Exception e)
{
Simple.ErrorAlert("Nepodařilo se ukončit modul", e.Message, this);
return;
}
}
}
protected override void Submit(SubmitArgs e)
{
if (e.Action == SubmitAction.Update || e.Action == SubmitAction.ChildrenOnly)
{
(e.Entity as ViewConfigurationModel).SaveToXml();
}
else
{
base.Submit(e);
}
}
/// <summary>
/// 提交聚合对象到数据库中。
///
/// 子类重写此方法实现整个聚合对象保存到非关系型数据库的逻辑。
/// 如果只想重写单个对象的 CUD 逻辑，请重写 Insert、Update、Delete 方法。
/// </summary>
/// <param name="e"></param>
protected internal virtual void Submit(SubmitArgs e)
{
_dataSaver.Submit(e);
}
