Beispiel #1
0
        public static void 提交(ArchiveOperationForm masterForm)
        {
            调节款 tjk = masterForm.ControlManager.DisplayManager.CurrentItem as 调节款;

            if (tjk == null)
            {
                return;
            }

            using (IRepository rep = RepositoryFactory.GenerateRepository <调节款>())
            {
                try
                {
                    rep.BeginTransaction();
                    tjk.Submitted = true;
                    rep.Update(tjk);

                    rep.Initialize(tjk, tjk.调节款明细);
                    foreach (调节款明细 i in tjk.调节款明细)
                    {
                        应收应付款 j = i.Clone() as 应收应付款;
                        j.应收应付源 = tjk;
                        rep.Save(j);
                    }

                    rep.CommitTransaction();
                }
                catch (Exception)
                {
                    rep.RollbackTransaction();
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// 提交
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="entity"></param>
        public override void Submit(IRepository rep, 坏账 entity)
        {
            对账单 dzd = new 对账单();

            dzd.对账单类型  = (int)财务对账单类型.坏账;
            dzd.结束日期   = entity.日期;
            dzd.费用     = new List <费用>();
            dzd.费用项编号  = entity.费用项编号;
            dzd.关账日期   = entity.日期;
            dzd.结算期限   = entity.日期;
            dzd.金额     = -entity.金额;
            dzd.收付标志   = entity.收付标志;
            dzd.送出时间   = entity.日期;
            dzd.相关人编号  = entity.相关人编号;
            dzd.业务类型编号 = entity.业务类型编号;

            dzd.Submitted = true;
            (new HdBaseDao <对账单>()).Save(rep, dzd);

            非业务费用 fy = new 非业务费用();

            fy.费用项编号 = "352";  // 坏账
            fy.费用实体  = entity;
            fy.金额    = entity.金额;
            fy.收付标志  = entity.收付标志 == 收付标志.付 ? 收付标志.收 : 收付标志.付;
            fy.相关人编号 = entity.相关人编号;
            fy.对账单   = dzd;
            (new 非业务费用Dao()).Save(rep, fy);
            dzd.费用.Add(fy);

            entity.费用 = new List <费用>();
            entity.费用.Add(fy);

            应收应付款 ysyfk = new 应收应付款();

            ysyfk.费用项编号  = entity.费用项编号;
            ysyfk.结算期限   = dzd.结算期限.HasValue ? dzd.结算期限.Value : dzd.关账日期.Value;
            ysyfk.金额     = dzd.金额;
            ysyfk.日期     = dzd.关账日期.Value;
            ysyfk.收付标志   = dzd.收付标志;
            ysyfk.相关人编号  = dzd.相关人编号;
            ysyfk.业务类型编号 = entity.业务类型编号;
            ysyfk.应收应付源  = dzd;

            (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);
            dzd.应收应付款 = new List <应收应付款>();
            dzd.应收应付款.Add(ysyfk);

            entity.对账单号      = dzd.编号;
            entity.Submitted = true;
            this.Update(rep, entity);
        }
Beispiel #3
0
        /// <summary>
        /// 提交
        /// </summary>
        /// <param name="rep"></param>
        /// <param name="entity"></param>
        public override void Submit(IRepository rep, 调节款 entity)
        {
            //rep.Initialize(entity, entity.调节款明细);
            //foreach (调节款明细 i in entity.调节款明细)
            //{
            //    应收应付款 j = new 应收应付款();
            //    j.备注 = entity.备注;
            //    j.费用项编号 = i.费用项编号;
            //    j.结算期限 = i.结算期限;
            //    j.金额 = i.金额;
            //    j.日期 = i.日期;
            //    j.收付标志 = i.收付标志;
            //    j.相关人编号 = i.相关人编号;
            //    j.业务类型编号 = i.业务类型编号;

            //    j.应收应付源 = entity;

            //    (new HdBaseDao<应收应付款>()).Save(rep, j);
            //}

            应收应付款 j = new 应收应付款();

            j.备注     = entity.备注;
            j.费用项编号  = entity.费用项编号;
            j.结算期限   = entity.结算期限.HasValue ? entity.结算期限.Value : entity.日期;
            j.金额     = entity.金额;
            j.日期     = entity.日期;
            j.收付标志   = entity.收付标志;
            j.相关人编号  = entity.相关人编号;
            j.业务类型编号 = entity.业务类型编号;

            j.应收应付源 = entity;

            (new HdBaseDao <应收应付款>()).Save(rep, j);

            entity.Submitted = true;
            this.Update(rep, entity);
        }
Beispiel #4
0
        public override void Submit(IRepository rep, 资产入库 entity)
        {
            应收应付款 ysyfk = new 应收应付款();

            ysyfk.备注     = entity.备注;
            ysyfk.结算期限   = entity.结算期限.HasValue ? entity.结算期限.Value : entity.日期;
            ysyfk.金额     = entity.金额;
            ysyfk.日期     = entity.日期;
            ysyfk.相关人编号  = entity.相关人编号;
            ysyfk.业务类型编号 = entity.业务类型编号;
            ysyfk.应收应付源  = entity;
            if (entity.业务类型编号 == 24) // 业务类型=固定资产  费用项 002 其他的  000
            {
                ysyfk.费用项编号 = "002";
            }
            else
            {
                ysyfk.费用项编号 = "000";
            }
            ysyfk.收付标志 = 收付标志.付;
            new HdBaseDao <应收应付款>().Save(rep, ysyfk);

            应收应付款 ysyf = new 应收应付款();

            ysyf.备注     = entity.备注;
            ysyf.结算期限   = entity.结算期限.HasValue ? entity.结算期限.Value : entity.日期;
            ysyf.金额     = entity.金额;
            ysyf.日期     = entity.日期;
            ysyf.相关人编号  = "900031";
            ysyf.业务类型编号 = entity.业务类型编号;
            ysyf.应收应付源  = entity;
            ysyf.费用项编号  = "004";
            ysyf.收付标志   = 收付标志.收;
            new HdBaseDao <应收应付款>().Save(rep, ysyf);

            entity.Submitted = true;
            this.Update(rep, entity);
        }
Beispiel #5
0
        internal static void GenerateDzdYsyf(IRepository rep, 对账单 entity)
        {
            if (!entity.Submitted)
            {
                throw new InvalidUserOperationException("对账单还未提交!");
            }

            entity.应收应付款 = new List <应收应付款>();

            // 费用实体类型=车辆产值, 费用类别=11 -》任务类别
            // 费用实体类型=车辆产值, 费用类别《》11 -》费用类别
            // 费用实体类型 <>车辆产值 -》费用实体类型

            switch (entity.对账单类型)
            {
            case (int)车队对账单类型.应收对账单_委托人:
            case (int)车队对账单类型.应付对账单_驾驶员:
            case (int)车队对账单类型.应付对账单_对外:
            case (int)车队对账单类型.应付对账单_车主:
            {
                if (entity.对账单类型 == (int)车队对账单类型.应付对账单_车主 && entity.相关人编号 == "900001")
                {
                    return;
                }
                // 任务类别, 收付标志,相关人编号
                Dictionary <Tuple <int, string>, IList <费用> > dict = GroupFy(entity.费用, rep);

                foreach (KeyValuePair <Tuple <int, string>, IList <费用> > kvp in dict)
                {
                    decimal sum = 0;
                    foreach (费用 k4 in kvp.Value)
                    {
                        if (k4.收付标志 == entity.收付标志)
                        {
                            sum += k4.金额.Value;
                        }
                        else
                        {
                            sum -= k4.金额.Value;
                        }
                    }

                    应收应付款 ysyfk = new 应收应付款();
                    ysyfk.费用项编号  = "000";
                    ysyfk.结算期限   = entity.结算期限.HasValue ? entity.结算期限.Value : entity.关账日期.Value;
                    ysyfk.金额     = sum;
                    ysyfk.日期     = entity.关账日期.Value;
                    ysyfk.收付标志   = entity.收付标志;
                    ysyfk.相关人编号  = kvp.Key.Item2;
                    ysyfk.业务类型编号 = kvp.Key.Item1;
                    ysyfk.应收应付源  = entity;

                    (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);

                    entity.应收应付款.Add(ysyfk);
                }
            }
            break;

            case (int)车队对账单类型.固定资产折旧_车辆:
                if (entity.对账单类型 == (int)车队对账单类型.固定资产折旧_车辆 && entity.相关人编号 == "900001")
                {
                    return;
                }
                // 任务类别, 收付标志,相关人编号
                Dictionary <Tuple <int, string>, IList <费用> > dic = GroupFy(entity.费用, rep);

                foreach (KeyValuePair <Tuple <int, string>, IList <费用> > kvp in dic)
                {
                    decimal sum = 0;
                    foreach (费用 k4 in kvp.Value)
                    {
                        if (k4.收付标志 == 收付标志.付)
                        {
                            sum -= k4.金额.Value;
                        }
                        else
                        {
                            sum += k4.金额.Value;
                        }
                    }

                    应收应付款 ysyfk = new 应收应付款();
                    ysyfk.费用项编号  = "004";
                    ysyfk.结算期限   = entity.关账日期.Value;
                    ysyfk.金额     = sum;
                    ysyfk.日期     = entity.关账日期.Value;
                    ysyfk.收付标志   = 收付标志.收;
                    ysyfk.相关人编号  = kvp.Key.Item2;
                    ysyfk.业务类型编号 = kvp.Key.Item1;
                    ysyfk.应收应付源  = entity;

                    (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);

                    entity.应收应付款.Add(ysyfk);
                }
                break;

            default:
                throw new NotSupportedException("Not Supported 对账单类型 of " + entity.对账单类型 + "!");
            }
        }
Beispiel #6
0
        private static void GeneratePzYsyf(IRepository rep, 凭证 pz)
        {
            rep.Initialize(pz.凭证费用明细, pz);

            foreach (凭证费用明细 pzfymx in pz.凭证费用明细)
            {
                rep.Initialize(pzfymx.费用, pzfymx);

                费用项 fyx = EntityBufferCollection.Instance.Get <费用项>(pzfymx.费用项编号);
                if (pzfymx.费用.Count > 0)
                {
                    // 通过对账单包进来的
                    if (fyx.应收应付类型 == 应收应付类型.业务)
                    {
                        应收应付款 ysyfk = new 应收应付款();
                        ysyfk.IsActive = true;
                        ysyfk.费用项编号    = pzfymx.费用项编号;
                        ysyfk.结算期限     = pz.日期;
                        ysyfk.金额       = -pzfymx.金额; // 取反
                        ysyfk.日期       = pz.日期;
                        ysyfk.收付标志     = pzfymx.收付标志;
                        ysyfk.相关人编号    = pzfymx.相关人编号;
                        ysyfk.业务类型编号   = pzfymx.业务类型编号.Value;
                        ysyfk.应收应付源    = pz;
                        ysyfk.备注       = pzfymx.备注;

                        (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);
                    }
                    continue;
                }


                if (fyx.应收应付类型 == 应收应付类型.业务)
                {
                    应收应付款 ysyfk = new 应收应付款();
                    ysyfk.IsActive = true;
                    ysyfk.费用项编号    = pzfymx.费用项编号;
                    ysyfk.结算期限     = pz.日期;
                    ysyfk.金额       = -pzfymx.金额; // 取反
                    ysyfk.日期       = pz.日期;
                    ysyfk.收付标志     = pzfymx.收付标志;
                    ysyfk.相关人编号    = pzfymx.相关人编号;
                    ysyfk.业务类型编号   = pzfymx.业务类型编号.Value;
                    ysyfk.应收应付源    = pz;
                    ysyfk.备注       = pzfymx.备注;

                    (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);
                }
                else if (fyx.应收应付类型 == 应收应付类型.借款类型)
                {
                    应收应付款 ysyfk = new 应收应付款();
                    ysyfk.IsActive = true;
                    ysyfk.费用项编号    = "002"; // 其他

                    //IList<GridColumnInfo> infos = new List<GridColumnInfo> {
                    //        new GridColumnInfo { Caption = "结算期限", DataControlVisible = "True", DataControlType = "MyDatePicker", PropertyName = "结算期限", NotNull = "True"} ,
                    //    };
                    //ArchiveDataControlForm form = new ArchiveDataControlForm(new ControlManager(null), infos);
                    //if (form.ShowDialog() == DialogResult.OK)
                    //{
                    //    ysyfk.结算期限 = (DateTime)form.DataControls["结算期限"].SelectedDataValue;
                    //}
                    //else
                    //{
                    //    throw new InvalidUserOperationException("借款必须填写结算期限!");
                    //}
                    ysyfk.结算期限   = pzfymx.结算期限.HasValue ? pzfymx.结算期限.Value : pz.日期;
                    ysyfk.金额     = pzfymx.金额;
                    ysyfk.日期     = pz.日期;
                    ysyfk.收付标志   = pzfymx.收付标志 == 收付标志.付 ? 收付标志.收 : 收付标志.付;
                    ysyfk.相关人编号  = pzfymx.相关人编号;
                    ysyfk.业务类型编号 = pzfymx.业务类型编号.Value;
                    ysyfk.应收应付源  = pz;
                    ysyfk.备注     = pzfymx.备注;

                    (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);
                }
                else if (fyx.应收应付类型 == 应收应付类型.管理费用类型)
                {
                    非业务费用 fy = new 非业务费用();
                    fy.IsActive = true;

                    fy.费用项编号 = pzfymx.费用项编号;
                    fy.金额    = pzfymx.金额;
                    fy.收付标志  = pzfymx.收付标志;
                    fy.相关人编号 = pzfymx.相关人编号;
                    fy.备注    = pzfymx.备注;

                    if (string.IsNullOrEmpty(s_非业务默认费用实体))
                    {
                        throw new ArgumentException("必须指定一个非业务默认费用实体!");
                    }
                    fy.费用实体 = rep.Get <费用实体>(new Guid(s_非业务默认费用实体));
                    if (fy.费用实体 == null)
                    {
                        throw new ArgumentException("指定的非业务默认费用实体不存在!");
                    }
                    fy.凭证费用明细 = pzfymx;

                    (new 非业务费用Dao()).Save(rep, fy);
                }
                else if (fyx.应收应付类型 == 应收应付类型.待分摊类型)
                {
                    应收应付款 ysyfk = new 应收应付款();
                    ysyfk.IsActive = true;
                    ysyfk.费用项编号    = "004"; // 其他
                    ysyfk.结算期限     = pzfymx.结算期限.HasValue ? pzfymx.结算期限.Value : pz.日期;
                    ysyfk.金额       = pzfymx.金额;
                    ysyfk.日期       = pz.日期;
                    ysyfk.收付标志     = pzfymx.收付标志 == 收付标志.付 ? 收付标志.收 : 收付标志.付;
                    ysyfk.相关人编号    = "900031";
                    ysyfk.业务类型编号   = pzfymx.业务类型编号.Value;
                    ysyfk.应收应付源    = pz;
                    ysyfk.备注       = pzfymx.备注;

                    (new HdBaseDao <应收应付款>()).Save(rep, ysyfk);
                }
                else if (fyx.应收应付类型 == 应收应付类型.其他)
                {
                }
            }
        }