public static void 批量生成费用付款(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱s, string 费用项编号, 收付标志?收付标志, IList <业务费用理论值> llzs, bool service)
{
if (!收付标志.HasValue || 收付标志.Value == Hd.Model.收付标志.付)
{
// 生成付款费用
付款合同 fkht = HdDataBuffer.Instance.Get付款合同(rep, 费用实体类型);
if (fkht != null)
{
foreach (付款合同费用项 htfyx in fkht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号) &&
htfyx.费用项编号 != 费用项编号)
{
continue;
}
// 不是服务运行时（即界面上点按钮），付款合同费用项.是否生成实际费用 = false 不生产费用
if (!service && !htfyx.是否生成实际费用)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.付, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
if (费用实体类型 == 11)
{
bool?cybz = ConvertHelper.ToBoolean(EntityScript.GetPropertyValue(票, "承运标志"));
if (cybz.HasValue && cybz.Value)
{
// 受托人合同
string str = ConvertHelper.ToString(EntityScript.GetPropertyValue(票, "承运人编号"));
if (!string.IsNullOrEmpty(str))
{
// 生成付款费用
受托人合同 strht = HdDataBuffer.Instance.Get受托人合同(rep, 费用实体类型, str);
if (strht != null)
{
foreach (受托人合同费用项 htfyx in strht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号) &&
htfyx.费用项编号 != 费用项编号)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.付, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
}
}
}
}
}
public static string Get相关人(IRepository rep, 普通票 票, 普通箱 箱, 合同费用项 htfyx)
{
object entity;
if (箱 != null)
{
entity = 箱;
}
else
{
entity = 票;
}
string ret = null;
if (htfyx is 委托人合同费用项)
{
return(票.委托人编号);
}
else if (htfyx is 付款合同费用项)
{
string mrxgr = (htfyx as 付款合同费用项).默认相关人;
object r = EntityScript.CalculateExpression(mrxgr, entity);
ret = string.IsNullOrEmpty(mrxgr) || r == null ? null : r.ToString().Replace("\"", "");
if (string.IsNullOrEmpty(ret))
{
ret = null;
}
}
else if (htfyx is 受托人合同费用项)
{
object cyr = EntityScript.GetPropertyValue(票, "承运人编号");
if (cyr != null)
{
return(cyr.ToString());
}
else
{
return(null);
}
}
else
{
throw new ArgumentException("Invalid htfyx Type!");
}
return(ret);
}
private static void 批量生成费用(IRepository rep, 普通票 票, IEnumerable 箱s, 收付标志 收付标志, 合同费用项 htfyx, IList <业务费用理论值> llzs, bool mustGenerateFy)
{
费用项 fyx = EntityBufferCollection.Instance.Get <费用项>(htfyx.费用项编号);
if (fyx.箱)
{
foreach (普通箱 箱 in 箱s)
{
GenerateFy(rep, 票, 箱, 收付标志, htfyx, llzs, mustGenerateFy);
}
}
else if (fyx.票)
{
GenerateFy(rep, 票, null, 收付标志, htfyx, llzs, mustGenerateFy);
}
}
public static string Get相关人(IRepository rep, 普通票 票, 普通箱 箱, 合同费用项 htfyx)
{
object entity;
if (箱 != null)
{
entity = 箱;
}
else
{
entity = 票;
}
string ret = null;
if (htfyx is 委托人合同费用项)
{
return 票.委托人编号;
}
else if (htfyx is 付款合同费用项)
{
string mrxgr = (htfyx as 付款合同费用项).默认相关人;
object r = EntityScript.CalculateExpression(mrxgr, entity);
ret = string.IsNullOrEmpty(mrxgr) || r == null ? null : r.ToString().Replace("\"", "");
if (string.IsNullOrEmpty(ret))
{
ret = null;
}
}
else if (htfyx is 受托人合同费用项)
{
object cyr = EntityScript.GetPropertyValue(票, "承运人编号");
if (cyr != null)
{
return cyr.ToString();
}
else
{
return null;
}
}
else
{
throw new ArgumentException("Invalid htfyx Type!");
}
return ret;
}
private static decimal?Get委托人理论值(IRepository rep, 普通票 票, 普通箱 箱, 委托人合同费用项 htfyx)
{
decimal?d = null;
switch (htfyx.委托人合同费用项类型)
{
case 委托人合同费用项类型.理论值计算:
d = (箱 != null) ? Get理论值金额(rep, htfyx, 箱) : Get理论值金额(rep, htfyx, 票);
break;
case 委托人合同费用项类型.代垫:
decimal?sum = null;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志.付 &&
i.金额.HasValue;
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
if (!sum.HasValue)
{
sum = 0;
}
sum += i.金额.Value;
}
}
if (sum.HasValue)
{
d = sum;
}
else
{
d = decimal.MinValue;
}
break;
default:
throw new ArgumentException("Invalid " + htfyx.委托人合同费用项类型);
}
return(d);
}
public static void 批量生成空费用项(ArchiveOperationForm masterForm)
{
普通票 piao = (masterForm.ParentForm as GeneratedArchiveOperationForm).DisplayManager.CurrentItem as 普通票;
if (piao == null)
{
return;
}
if (masterForm.DisplayManager.Items.Count > 0)
{
if (!MessageForm.ShowYesNo("是否确定生成空费用项", "提示"))
{
return;
}
}
using (IRepository rep = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <普通票>())
{
IList <费用项> fyxList = (rep as Feng.NH.INHibernateRepository).Session.CreateSQLQuery(
"select * from 参数备案_费用项 where 现有费用实体类型 like '%" + piao.费用实体类型编号 + ",%' and 票 = 1")
.AddEntity(typeof(费用项)).List <费用项>();
if (fyxList == null || fyxList.Count == 0)
{
return;
}
foreach (费用项 fyx in fyxList)
{
业务费用 fy = new 业务费用
{
费用项编号 = fyx.编号,
收付标志 = 收付标志.付,
票 = piao
};
masterForm.ControlManager.AddNew();
masterForm.ControlManager.DisplayManager.Items[masterForm.DisplayManager.Position] = fy;
masterForm.ControlManager.EndEdit();
}
}
}
private static decimal?Get理论值(IRepository rep, 普通票 票, 普通箱 箱, 合同费用项 htfyx)
{
if (htfyx is 受托人合同费用项)
{
return(Get受托人理论值(rep, 票, 箱, htfyx as 受托人合同费用项));
}
else if (htfyx is 付款合同费用项)
{
return(Get付款理论值(rep, 票, 箱, htfyx as 付款合同费用项));
}
else if (htfyx is 委托人合同费用项)
{
return(Get委托人理论值(rep, 票, 箱, htfyx as 委托人合同费用项));
}
else
{
throw new ArgumentException("Invalid htfyx Type!");
}
}
public static int 批量生成费用(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱, string 费用项编号, 收付标志?收付标志, bool service)
{
int cnt = 0;
// 需按照委托人合同和付款合同生成相应费用和费用理论值
// 如果总体来生成，则按照：
// 如果费用已经打了完全标志，则不生成。如果相应理论值已经生成过，也不生成。
// 如果单个费用项来生成，则不管理论值是否已经生成过
// Todo: 理论值可能显示生成票的，后来信息完全了再生成箱的，此时要删除票的
//using (IRepository rep = ServiceProvider.GetService<IRepositoryFactory>().GenerateRepository(票.GetType()))
{
try
{
rep.BeginTransaction();
IList <业务费用理论值> llzs = (rep as Feng.NH.INHibernateRepository).List <业务费用理论值>(NHibernate.Criterion.DetachedCriteria.For <业务费用理论值>()
.Add(NHibernate.Criterion.Expression.Eq("费用实体.ID", 票.ID)));
rep.Initialize(票.费用, 票);
process_fy_generate.批量生成费用付款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs, service);
process_fy_generate.批量生成费用收款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs);
//// 有几项（发票税，贴息费）要看收款费用
// 不行，会多生成
//批量生成费用付款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs);
// 不知道哪里更改了，会update
(rep as Feng.NH.INHibernateRepository).Session.Evict(票);
rep.CommitTransaction();
}
catch (Exception ex)
{
rep.RollbackTransaction();
ServiceProvider.GetService <IExceptionProcess>().ProcessWithNotify(ex);
}
}
return(cnt);
}
public static void 批量生成费用收款(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱s, string 费用项编号, 收付标志?收付标志, IList <业务费用理论值> llzs)
{
if (!收付标志.HasValue || 收付标志.Value == Hd.Model.收付标志.收)
{
// 生成委托人合同费用
委托人合同 wtrht = HdDataBuffer.Instance.Get委托人合同(rep, 费用实体类型, 票.委托人编号);
if (wtrht != null)
{
foreach (委托人合同费用项 htfyx in wtrht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号) &&
htfyx.费用项编号 != 费用项编号)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.收, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
}
}
public override bool DoSave()
{
//if (!this.ControlManager.CheckControlValue())
//{
// return false;
//}
this.ValidateChildren();
if (!this.ControlManager.SaveCurrent())
{
return(false);
}
凭证 pz = this.ControlManager.DisplayManager.CurrentItem as 凭证;
pz.操作人 = "会计";
using (var rep = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <Hd.Model.凭证>() as Feng.NH.INHibernateRepository)
{
try
{
rep.BeginTransaction();
decimal sum = 0;
pz.凭证费用明细 = new List <凭证费用明细>();
foreach (Xceed.Grid.DataRow row in grdFymx.DataRows)
{
decimal je = Feng.Utils.ConvertHelper.ToDecimal(row.Cells["金额"].Value).Value;
sum += je;
凭证费用明细 pzfymx = new 凭证费用明细();
pzfymx.备注 = (string)row.Cells["备注"].Value;
pzfymx.金额 = je;
pzfymx.凭证 = pz;
pzfymx.凭证费用类别编号 = (int?)row.Cells["凭证费用类别"].Value;
pzfymx.收付标志 = Hd.Model.收付标志.付;
pzfymx.相关人编号 = (string)付款对象.SelectedDataValue;
pzfymx.业务类型编号 = (int?)row.Cells["业务分类"].Value;
pzfymx.费用项编号 = (string)row.Cells["费用项"].Value;
pzfymx.费用 = new List <费用>();
pzfymx.结算期限 = (DateTime?)row.Cells["结算期限"].Value;
凭证用途分类 ytfl = (凭证用途分类)用途分类.SelectedDataValue;
if (ytfl == 凭证用途分类.业务应付) // 业务应付
{
pzfymx.业务类型编号 = (int?)业务分类.SelectedDataValue;
}
else if (ytfl == 凭证用途分类.其他应付)
{
pzfymx.业务类型编号 = 111;
pzfymx.费用项编号 = "002";
}
else if (ytfl == 凭证用途分类.其他报销)
{
pzfymx.费用项编号 = (string)row.Cells["费用项"].Value;
}
else if (ytfl == 凭证用途分类.业务报销)
{
普通票 piao = null;
普通箱 xiang = null;
piao = rep.UniqueResult <Hd.Model.普通票>(NHibernate.Criterion.DetachedCriteria.For <Hd.Model.普通票>()
.Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value)));
if (piao == null)
{
throw new InvalidUserOperationException("自编号" + (string)row.Cells["自编号"].Value + "输入有误，请重新输入！");
}
switch (业务分类.SelectedDataValue.ToString())
{
case "11":
using (var rep2 = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <Hd.Model.Jk.进口箱>() as Feng.NH.INHibernateRepository)
{
if (row.Cells["箱号"].Value != null)
{
xiang = rep2.UniqueResult <Hd.Model.Jk.进口箱>(NHibernate.Criterion.DetachedCriteria.For <Hd.Model.Jk.进口箱>()
.Add(NHibernate.Criterion.Expression.Eq("箱号", row.Cells["箱号"].Value))
.CreateCriteria("票")
.Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value)));
if (xiang == null)
{
throw new InvalidUserOperationException("箱号" + (string)row.Cells["箱号"].Value + "输入有误，请重新输入！");
}
}
}
break;
case "15":
using (var rep2 = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <Hd.Model.Jk.进口箱>() as Feng.NH.INHibernateRepository)
{
//piao = rep2.Session.CreateCriteria<Hd.Model.普通票>()
// .Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value))
// .UniqueResult<Hd.Model.普通票>();
//if (piao == null)
//{
// throw new InvalidUserOperationException("自编号" + (string)row.Cells["自编号"].Value + "输入有误，请重新输入！");
//}
if (row.Cells["箱号"].Value != null)
{
xiang = rep2.UniqueResult <Hd.Model.Nmcg.内贸出港箱>(NHibernate.Criterion.DetachedCriteria.For <Hd.Model.Nmcg.内贸出港箱>()
.Add(NHibernate.Criterion.Expression.Eq("箱号", row.Cells["箱号"].Value))
.CreateCriteria("票")
.Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value)));
if (xiang == null)
{
throw new InvalidUserOperationException("箱号" + (string)row.Cells["箱号"].Value + "输入有误，请重新输入！");
}
}
}
break;
case "45":
using (var rep2 = ServiceProvider.GetService <IRepositoryFactory>().GenerateRepository <Hd.Model.Jk.进口票>() as Feng.NH.INHibernateRepository)
{
//piao = rep2.Session.CreateCriteria<Hd.Model.普通票>()
// .Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value))
// .UniqueResult<Hd.Model.普通票>();
//if (piao == null)
//{
// throw new InvalidUserOperationException("自编号" + (string)row.Cells["自编号"].Value + "输入有误，请重新输入！");
//}
if (row.Cells["箱号"].Value != null)
{
xiang = rep2.UniqueResult <Hd.Model.Jk2.进口其他业务箱>(NHibernate.Criterion.DetachedCriteria.For <Hd.Model.Jk2.进口其他业务箱>()
.Add(NHibernate.Criterion.Expression.Eq("箱号", row.Cells["箱号"].Value))
.CreateCriteria("票")
.Add(NHibernate.Criterion.Expression.Eq("货代自编号", row.Cells["自编号"].Value)));
if (xiang == null)
{
throw new InvalidUserOperationException("箱号" + (string)row.Cells["箱号"].Value + "输入有误，请重新输入！");
}
}
}
break;
default:
throw new ArgumentException("不合理的业务类型分类！");
}
NHibernate.Criterion.DetachedCriteria cri = NHibernate.Criterion.DetachedCriteria.For <业务费用>()
.Add(NHibernate.Criterion.Expression.Eq("票.ID", piao.ID))
.Add(NHibernate.Criterion.Expression.Eq("费用项编号", row.Cells["费用项"].Value))
.Add(NHibernate.Criterion.Expression.Eq("收付标志", Hd.Model.收付标志.付));
if (xiang != null)
{
cri = cri.Add(NHibernate.Criterion.Expression.Eq("箱.ID", xiang.ID));
}
else
{
cri = cri.Add(NHibernate.Criterion.Expression.IsNull("箱"));
}
IList <业务费用> list = rep.List <业务费用>(cri);
cri = NHibernate.Criterion.DetachedCriteria.For <费用信息>()
.Add(NHibernate.Criterion.Expression.Eq("票.ID", piao.ID))
.Add(NHibernate.Criterion.Expression.Eq("费用项编号", row.Cells["费用项"].Value));
IList <费用信息> fyxxs = rep.List <费用信息>(cri);
if (fyxxs.Count > 0)
{
if (!fyxxs[0].完全标志付)
{
fyxxs[0].完全标志付 = true;
(new HdBaseDao <费用信息>()).Update(rep, fyxxs[0]);
}
else
{
throw new InvalidUserOperationException("货代自编号" + piao.货代自编号 + "费用项" + row.Cells["费用项"].Value.ToString()
+ "已打完全标志，不能修改费用！");
}
}
bool exist = false;
if (list.Count > 0)
{
foreach (业务费用 i in list)
{
if (i.金额 == je && i.相关人编号 == pzfymx.相关人编号 && i.凭证费用明细 == null)
{
i.凭证费用明细 = pzfymx;
(new 业务费用Dao()).Update(rep, i);
pzfymx.费用.Add(i);
exist = true;
break;
}
}
}
if (!exist)
{
if (list.Count > 1)
{
throw new InvalidUserOperationException("货代自编号" + piao.货代自编号 + "费用项" + row.Cells["费用项"].Value.ToString()
+ "已存在多条费用，且无费用金额一致，请先修改一致！");
}
else if (list.Count == 0)
{
业务费用 fy = new 业务费用();
fy.备注 = (string)row.Cells["备注"].Value;
fy.费用实体 = piao;
fy.费用项编号 = (string)row.Cells["费用项"].Value;
fy.金额 = Feng.Utils.ConvertHelper.ToDecimal(row.Cells["金额"].Value).Value;
fy.票 = piao;
fy.凭证费用明细 = pzfymx;
fy.收付标志 = Hd.Model.收付标志.付;
fy.相关人编号 = (string)付款对象.SelectedDataValue;
if (xiang != null)
{
fy.箱 = xiang;
fy.箱Id = xiang.ID;
}
(new 业务费用Dao()).Save(rep, fy);
pzfymx.费用.Add(fy);
}
else// if (list.Count == 1)
{
if (list[0].相关人编号 == pzfymx.相关人编号 && list[0].凭证费用明细 == null)
{
if (MessageForm.ShowYesNo("货代自编号" + piao.货代自编号 + "费用项" + row.Cells["费用项"].Value.ToString()
+ "已存在费用，且费用金额不符，是否添加调节款？", "确认"))
{
调节业务款 tjk = new 调节业务款();
tjk.备注 = (string)row.Cells["备注"].Value;
tjk.费用实体 = piao;
tjk.费用项编号 = (string)row.Cells["费用项"].Value;
tjk.金额 = Feng.Utils.ConvertHelper.ToDecimal(row.Cells["金额"].Value).Value;
tjk.票 = piao;
tjk.凭证费用明细 = pzfymx;
tjk.收付标志 = Hd.Model.收付标志.付;
tjk.相关人编号 = (string)付款对象.SelectedDataValue;
if (xiang != null)
{
tjk.箱 = xiang;
tjk.箱Id = xiang.ID;
}
(new 费用Dao()).Save(rep, tjk);
pzfymx.费用.Add(tjk);
}
else
{
throw new InvalidUserOperationException("请重新填写货代自编号！");
}
}
else
{
throw new InvalidUserOperationException("货代自编号" + piao.货代自编号 + "费用项" + row.Cells["费用项"].Value.ToString()
+ "已存在的一条费用相关人不符或已经出国凭证，请先修改一致！");
}
}
}
}
else
{
throw new ArgumentException("不合理的凭证用途分类！");
}
pz.凭证费用明细.Add(pzfymx);
}
pz.会计编号 = SystemConfiguration.UserName;
pz.会计金额 = sum;
pz.金额.币制编号 = "CNY";
pz.金额.数额 = pz.会计金额;
pz.凭证类别 = 凭证类别.付款凭证;
pz.相关人编号 = (string)付款对象.SelectedDataValue;
pz.自动手工标志 = 自动手工标志.手工;
(new 凭证Dao()).Save(rep, pz);
foreach (凭证费用明细 pzfymx in pz.凭证费用明细)
{
(new HdBaseDao <凭证费用明细>()).Save(rep, pzfymx);
}
(new 凭证Dao()).Submit(rep, pz);
rep.CommitTransaction();
if (this.ControlManager.ControlCheckExceptionProcess != null)
{
this.ControlManager.ControlCheckExceptionProcess.ClearAllError();
}
this.ControlManager.State = StateType.View;
this.ControlManager.OnCurrentItemChanged();
// don't save to database
this.ControlManager.EndEdit(false);
return(true);
}
catch (Exception ex)
{
rep.RollbackTransaction();
ServiceProvider.GetService <IExceptionProcess>().ProcessWithNotify(ex);
return(false);
}
}
}
private static void 批量生成费用(IRepository rep, 普通票 票, IEnumerable 箱s, 收付标志 收付标志, 合同费用项 htfyx, IList<业务费用理论值> llzs, bool mustGenerateFy)
{
费用项 fyx = EntityBufferCollection.Instance.Get<费用项>(htfyx.费用项编号);
if (fyx.箱)
{
foreach (普通箱 箱 in 箱s)
{
GenerateFy(rep, 票, 箱, 收付标志, htfyx, llzs, mustGenerateFy);
}
}
else if (fyx.票)
{
GenerateFy(rep, 票, null, 收付标志, htfyx, llzs, mustGenerateFy);
}
}
private static decimal? Get理论值(IRepository rep, 普通票 票, 普通箱 箱, 合同费用项 htfyx)
{
if (htfyx is 受托人合同费用项)
{
return Get受托人理论值(rep, 票, 箱, htfyx as 受托人合同费用项);
}
else if (htfyx is 付款合同费用项)
{
return Get付款理论值(rep, 票, 箱, htfyx as 付款合同费用项);
}
else if (htfyx is 委托人合同费用项)
{
return Get委托人理论值(rep, 票, 箱, htfyx as 委托人合同费用项);
}
else
{
throw new ArgumentException("Invalid htfyx Type!");
}
}
private static decimal? Get委托人理论值(IRepository rep, 普通票 票, 普通箱 箱, 委托人合同费用项 htfyx)
{
decimal? d = null;
switch (htfyx.委托人合同费用项类型)
{
case 委托人合同费用项类型.理论值计算:
d = (箱 != null) ? Get理论值金额(rep, htfyx, 箱) : Get理论值金额(rep, htfyx, 票);
break;
case 委托人合同费用项类型.代垫:
decimal? sum = null;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志.付
&& i.金额.HasValue;
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
if (!sum.HasValue)
{
sum = 0;
}
sum += i.金额.Value;
}
}
if (sum.HasValue)
{
d = sum;
}
else
{
d = decimal.MinValue;
}
break;
default:
throw new ArgumentException("Invalid " + htfyx.委托人合同费用项类型);
}
return d;
}
public static int 批量生成费用(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱, string 费用项编号, 收付标志? 收付标志)
{
return 批量生成费用(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, false);
}
public static void 批量生成费用付款(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱s, string 费用项编号, 收付标志? 收付标志, IList<业务费用理论值> llzs, bool service)
{
if (!收付标志.HasValue || 收付标志.Value == Hd.Model.收付标志.付)
{
// 生成付款费用
付款合同 fkht = HdDataBuffer.Instance.Get付款合同(rep, 费用实体类型);
if (fkht != null)
{
foreach (付款合同费用项 htfyx in fkht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号)
&& htfyx.费用项编号 != 费用项编号)
{
continue;
}
// 不是服务运行时（即界面上点按钮），付款合同费用项.是否生成实际费用 = false 不生产费用
if (!service && !htfyx.是否生成实际费用)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.付, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
if (费用实体类型 == 11)
{
bool? cybz = ConvertHelper.ToBoolean(EntityScript.GetPropertyValue(票, "承运标志"));
if (cybz.HasValue && cybz.Value)
{
// 受托人合同
string str = ConvertHelper.ToString(EntityScript.GetPropertyValue(票, "承运人编号"));
if (!string.IsNullOrEmpty(str))
{
// 生成付款费用
受托人合同 strht = HdDataBuffer.Instance.Get受托人合同(rep, 费用实体类型, str);
if (strht != null)
{
foreach (受托人合同费用项 htfyx in strht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号)
&& htfyx.费用项编号 != 费用项编号)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.付, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
}
}
}
}
}
public static int 批量生成费用(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱, string 费用项编号, 收付标志?收付标志)
{
return(批量生成费用(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, false));
}
public static void 批量生成费用收款(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱s, string 费用项编号, 收付标志? 收付标志, IList<业务费用理论值> llzs)
{
if (!收付标志.HasValue || 收付标志.Value == Hd.Model.收付标志.收)
{
// 生成委托人合同费用
委托人合同 wtrht = HdDataBuffer.Instance.Get委托人合同(rep, 费用实体类型, 票.委托人编号);
if (wtrht != null)
{
foreach (委托人合同费用项 htfyx in wtrht.合同费用项)
{
// 如果指定费用项，则只生成此费用项下的费用
if (!string.IsNullOrEmpty(费用项编号)
&& htfyx.费用项编号 != 费用项编号)
{
continue;
}
批量生成费用(rep, 票, 箱s, Hd.Model.收付标志.收, htfyx, llzs, !string.IsNullOrEmpty(费用项编号));
}
}
}
}
private static void GenerateFy(IRepository rep, 普通票 票, 普通箱 箱, 收付标志 收付标志, 合同费用项 htfyx, IList<业务费用理论值> llzs, bool mustGenerateFy)
{
string 相关人 = Get相关人(rep, 票, 箱, htfyx);
decimal? 金额 = Get理论值(rep, 票, 箱, htfyx);
if (金额.HasValue && 金额.Value == decimal.MinValue)
{
return;
}
bool llrHaveGenerated = false;
foreach (业务费用理论值 i in llzs)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志; ;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
llrHaveGenerated = true;
break;
}
}
业务费用理论值 ywfylrz = null;
if (!llrHaveGenerated)
{
if (金额.HasValue)
{
ywfylrz = new 业务费用理论值();
ywfylrz.费用实体 = 票; // new 普通票 { Id = 票.ID, Version = 票.Version, 费用实体类型编号 = 票.费用实体类型编号 };
ywfylrz.费用项编号 = htfyx.费用项编号;
ywfylrz.金额 = 金额.Value;
ywfylrz.票 = 票;
ywfylrz.收付标志 = 收付标志;
ywfylrz.相关人编号 = Get相关人(rep, 票, 箱, htfyx);
if (箱 != null)
{
ywfylrz.箱 = 箱;
ywfylrz.箱Id = 箱.ID;
}
(new HdBaseDao<业务费用理论值>()).Save(rep, ywfylrz);
llzs.Add(ywfylrz);
}
}
if (htfyx.是否生成实际费用)
{
bool generateFy = false;
// 在外层，判断理论值是否生成过
if (!mustGenerateFy)
{
if (htfyx.是否空值全部生成)
{
// 金额为Null的时候判断时候生成过，没生成过也要生成
if (!金额.HasValue)
{
bool fyHaveGenerated = false;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
fyHaveGenerated = true;
break;
}
}
generateFy = !fyHaveGenerated;
}
}
if (!generateFy)
{
// 只有理论值未生成过，且有理论值的情况下，准备生成费用
if (!llrHaveGenerated && ywfylrz != null)
{
// 如果理论值未生成过，要检查是否要生成费用
bool fyHaveGenerated = false;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
fyHaveGenerated = true;
break;
}
}
generateFy = !fyHaveGenerated;
}
else
{
generateFy = false;
}
}
}
else
{
generateFy = true;
}
if (generateFy)
{
bool fylbSubmitted = false;
费用项 fyx = EntityBufferCollection.Instance.Get<费用项>(htfyx.费用项编号);
//int fylbbh = fyx.收入类别.Value;
//费用类别 fylb = EntityBufferCollection.Instance["费用类别"].Get(fylbbh) as 费用类别;
//System.Diagnostics.Debug.Assert(fylb.大类 == "业务额外" || fylb.大类 == "业务常规" || fylb.大类 == "业务其他");
IList<费用信息> list = (rep as Feng.NH.INHibernateRepository).List<费用信息>(NHibernate.Criterion.DetachedCriteria.For<费用信息>()
.Add(NHibernate.Criterion.Expression.Eq("费用项编号", htfyx.费用项编号))
.Add(NHibernate.Criterion.Expression.Eq("票.ID", 票.ID)));
System.Diagnostics.Debug.Assert(list.Count <= 1);
if (list.Count == 1)
{
if (收付标志 == 收付标志.收)
{
fylbSubmitted = list[0].Submitted;
}
else
{
fylbSubmitted = list[0].完全标志付;
}
}
// 完全标志还未打
if (!fylbSubmitted)
{
// 不生成理论值为0的
if (!金额.HasValue || (金额.HasValue && 金额.Value != 0))
{
业务费用 item = new 业务费用();
item.费用实体 = 票; // new 普通票 { Id = 票.ID, Version = 票.Version, 费用实体类型编号 = 票.费用实体类型编号 };
item.费用项编号 = htfyx.费用项编号;
item.金额 = 金额;
item.票 = 票;
item.收付标志 = 收付标志;
item.相关人编号 = 相关人;
if (箱 != null)
{
item.箱 = 箱;
item.箱Id = 箱.ID;
}
(new 业务费用Dao()).Save(rep, item);
票.费用.Add(item);
}
}
}
}
}
public static int 批量生成费用(IRepository rep, int 费用实体类型, 普通票 票, IEnumerable 箱, string 费用项编号, 收付标志? 收付标志, bool service)
{
int cnt = 0;
// 需按照委托人合同和付款合同生成相应费用和费用理论值
// 如果总体来生成，则按照：
// 如果费用已经打了完全标志，则不生成。如果相应理论值已经生成过，也不生成。
// 如果单个费用项来生成，则不管理论值是否已经生成过
// Todo: 理论值可能显示生成票的，后来信息完全了再生成箱的，此时要删除票的
//using (IRepository rep = ServiceProvider.GetService<IRepositoryFactory>().GenerateRepository(票.GetType()))
{
try
{
rep.BeginTransaction();
IList<业务费用理论值> llzs = (rep as Feng.NH.INHibernateRepository).List<业务费用理论值>(NHibernate.Criterion.DetachedCriteria.For<业务费用理论值>()
.Add(NHibernate.Criterion.Expression.Eq("费用实体.ID", 票.ID)));
rep.Initialize(票.费用, 票);
process_fy_generate.批量生成费用付款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs, service);
process_fy_generate.批量生成费用收款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs);
//// 有几项（发票税，贴息费）要看收款费用
// 不行，会多生成
//批量生成费用付款(rep, 费用实体类型, 票, 箱, 费用项编号, 收付标志, llzs);
// 不知道哪里更改了，会update
(rep as Feng.NH.INHibernateRepository).Session.Evict(票);
rep.CommitTransaction();
}
catch (Exception ex)
{
rep.RollbackTransaction();
ServiceProvider.GetService<IExceptionProcess>().ProcessWithNotify(ex);
}
}
return cnt;
}
private static void GenerateFy(IRepository rep, 普通票 票, 普通箱 箱, 收付标志 收付标志, 合同费用项 htfyx, IList <业务费用理论值> llzs, bool mustGenerateFy)
{
string 相关人 = Get相关人(rep, 票, 箱, htfyx);
decimal?金额 = Get理论值(rep, 票, 箱, htfyx);
if (金额.HasValue && 金额.Value == decimal.MinValue)
{
return;
}
bool llrHaveGenerated = false;
foreach (业务费用理论值 i in llzs)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志;;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
llrHaveGenerated = true;
break;
}
}
业务费用理论值 ywfylrz = null;
if (!llrHaveGenerated)
{
if (金额.HasValue)
{
ywfylrz = new 业务费用理论值();
ywfylrz.费用实体 = 票; // new 普通票 { Id = 票.ID, Version = 票.Version, 费用实体类型编号 = 票.费用实体类型编号 };
ywfylrz.费用项编号 = htfyx.费用项编号;
ywfylrz.金额 = 金额.Value;
ywfylrz.票 = 票;
ywfylrz.收付标志 = 收付标志;
ywfylrz.相关人编号 = Get相关人(rep, 票, 箱, htfyx);
if (箱 != null)
{
ywfylrz.箱 = 箱;
ywfylrz.箱Id = 箱.ID;
}
(new HdBaseDao <业务费用理论值>()).Save(rep, ywfylrz);
llzs.Add(ywfylrz);
}
}
if (htfyx.是否生成实际费用)
{
bool generateFy = false;
// 在外层，判断理论值是否生成过
if (!mustGenerateFy)
{
if (htfyx.是否空值全部生成)
{
// 金额为Null的时候判断时候生成过，没生成过也要生成
if (!金额.HasValue)
{
bool fyHaveGenerated = false;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
fyHaveGenerated = true;
break;
}
}
generateFy = !fyHaveGenerated;
}
}
if (!generateFy)
{
// 只有理论值未生成过，且有理论值的情况下，准备生成费用
if (!llrHaveGenerated && ywfylrz != null)
{
// 如果理论值未生成过，要检查是否要生成费用
bool fyHaveGenerated = false;
foreach (业务费用 i in 票.费用)
{
bool b = i.费用项编号 == htfyx.费用项编号 && i.收付标志 == 收付标志;
if (htfyx.是否判断相关人)
{
b &= i.相关人编号 == 相关人;
}
if (b && 箱 != null)
{
b &= i.箱Id == 箱.ID;
}
if (b)
{
fyHaveGenerated = true;
break;
}
}
generateFy = !fyHaveGenerated;
}
else
{
generateFy = false;
}
}
}
else
{
generateFy = true;
}
if (generateFy)
{
bool fylbSubmitted = false;
费用项 fyx = EntityBufferCollection.Instance.Get <费用项>(htfyx.费用项编号);
//int fylbbh = fyx.收入类别.Value;
//费用类别 fylb = EntityBufferCollection.Instance["费用类别"].Get(fylbbh) as 费用类别;
//System.Diagnostics.Debug.Assert(fylb.大类 == "业务额外" || fylb.大类 == "业务常规" || fylb.大类 == "业务其他");
IList <费用信息> list = (rep as Feng.NH.INHibernateRepository).List <费用信息>(NHibernate.Criterion.DetachedCriteria.For <费用信息>()
.Add(NHibernate.Criterion.Expression.Eq("费用项编号", htfyx.费用项编号))
.Add(NHibernate.Criterion.Expression.Eq("票.ID", 票.ID)));
System.Diagnostics.Debug.Assert(list.Count <= 1);
if (list.Count == 1)
{
if (收付标志 == 收付标志.收)
{
fylbSubmitted = list[0].Submitted;
}
else
{
fylbSubmitted = list[0].完全标志付;
}
}
// 完全标志还未打
if (!fylbSubmitted)
{
// 不生成理论值为0的
if (!金额.HasValue || (金额.HasValue && 金额.Value != 0))
{
业务费用 item = new 业务费用();
item.费用实体 = 票; // new 普通票 { Id = 票.ID, Version = 票.Version, 费用实体类型编号 = 票.费用实体类型编号 };
item.费用项编号 = htfyx.费用项编号;
item.金额 = 金额;
item.票 = 票;
item.收付标志 = 收付标志;
item.相关人编号 = 相关人;
if (箱 != null)
{
item.箱 = 箱;
item.箱Id = 箱.ID;
}
(new 业务费用Dao()).Save(rep, item);
票.费用.Add(item);
}
}
}
}
}
