コード例 #1
0
        protected override void BeforeChange(DataColumn dc, DataRow ddr)
        {
            atriumDB.ActivityTimeRow dr = (atriumDB.ActivityTimeRow)ddr;

            switch (dc.ColumnName)
            {
            case "OfficeId":
                if (dr.IsOfficeIdNull())
                {
                    throw new RequiredException(dc.ColumnName);
                }
                else if (!myA.CheckDomain(dr.OfficeId, myA.Codes("OfficeList")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dc.Table.TableName, "Office List");
                }
                break;

            case ActivityFields.OfficerId:
                if (dr.IsOfficerIdNull())
                {
                    throw new RequiredException(dc.ColumnName);
                }
                else if (!myA.CheckDomain(dr.OfficerId, myA.Codes("OfficerList")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dc.Table.TableName, "Officer List");
                }
                break;

            case ActivityFields.Hours:
                //JLL: 2014-10-16 Change from minute to hour
                //if (dr.Hours > (24 * 60))
                if (!fixingHours)
                {
                    if (dr.Hours > 24)
                    {
                        throw new AtriumException("Minutes cannot be greater than 1440 minutes (24 hours) for one entry");
                    }
                    //if (dr.OfficeId != this.myA.AtMng.OfficeLoggedOn.OfficeId || (dr.Final && !dr.IsIRPIdNull()))
                    //    throw new AtriumException(atriumBE.Properties.Resources.ActivityTimeCannotEditHoursFees);
                }
                break;

            case ActivityFields.IRPId:
            case ActivityFields.FeesClaimed:
            case ActivityFields.FeesClaimedTax:
            case ActivityFields.Posted:
            case ActivityFields.Final:
                //if (dr.OfficeId != this.myA.AtMng.OfficeLoggedOn.OfficeId || (dr.Final && !dr.IsIRPIdNull()))
                //    throw new AtriumException(atriumBE.Properties.Resources.ActivityTimeCannotEditHoursFees);
                break;

            case ActivityFields.Taxed:
                if (!dr.Final && dr.Taxed)
                {
                    throw new AtriumException(atriumBE.Properties.Resources.ActivityTimeCannotTax);
                }
                break;
            }
        }
コード例 #2
0
        protected override void BeforeChange(DataColumn dc, DataRow ddr)
        {
            atriumDB.FileContactRow dr = (atriumDB.FileContactRow)ddr;
            switch (dc.ColumnName)
            {
            case "ContactType":
                if (!myA.CheckDomain(dr.ContactType, myA.Codes("ContactType")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "Contact Type");
                }

                //if contact type is once per file see if it it on any other records
                bool once = false;
                once = (bool)myA.Codes("ContactType").Select("ContactTypeCode='" + dr.ContactType + "'")[0]["OncePerFile"];
                if (once)
                {
                    foreach (atriumDB.FileContactRow fcr1 in myFileContactDT)
                    {
                        if (!fcr1.IsNull("ContactType") && fcr1.ContactType == dr.ContactType && dr.FileContactid != fcr1.FileContactid)
                        {
                            throw new AtriumException("A contact of type, {0}, already exists on this file.  You cannot add another.", dr.ContactType);
                        }
                    }
                }
                break;

            default:
                break;
            }
        }
コード例 #3
0
        protected override void BeforeChange(DataColumn dc, DataRow ddr)
        {
            atriumDB.FileOfficeRow dr = (atriumDB.FileOfficeRow)ddr;
            switch (dc.ColumnName)
            {
            case "OfficeId":
                if (dr.RowState != DataRowState.Added && !myA.CheckDomain(dr.OfficeId, myA.Codes("OfficeList")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "Office List");
                }
                break;

            default:
                break;
            }
        }
コード例 #4
0
        protected override void BeforeChange(DataColumn dc, DataRow ddr)
        {
            string ObjectName = this.myDisbursementDT.TableName;

            atriumDB.DisbursementRow dr = (atriumDB.DisbursementRow)ddr;
            switch (dc.ColumnName)
            {
            case DisbursementFields.DisbDate:
                if (dr.IsDisbDateNull() || myA.IsEmpty(dr.DisbDate.ToString()))
                {
                    throw new RequiredException(Resources.DisbursementDisbDate);
                }
                this.myA.IsValidDate(Resources.DisbursementDisbDate, dr.DisbDate, false, DateTime.Today.AddMonths(-6), DateTime.Today, Resources.ValidationSixMonthsAgo, Resources.ValidationToday);
                break;

            case DisbursementFields.DisbType:
                if (dr.IsNull(dc) || dr.DisbType.Length == 0)
                {
                    throw new RequiredException(Resources.DisbursementDisbType);
                }
                else if (!myA.CheckDomain(dr.DisbType, myA.Codes("DisbursementType")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "Dsibursement Type");
                }
                break;

            case "TaxRateId":
                if (!dr.IsTaxRateIdNull() && !myA.CheckDomain(dr.TaxRateId, myA.Codes("TaxRate")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dc.Table.TableName, "Tax Rate");
                }
                break;

            case "OfficeId":
                if (!myA.CheckDomain(dr.OfficeId, myA.Codes("OfficeList")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.IsNotValid, dc.ColumnName);
                }
                else if (!myA.CheckDomain(dr.OfficeId, myA.Codes("officelist")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dc.Table.TableName, "Office List");
                }
                break;

            case DisbursementFields.IRPId:
            case DisbursementFields.DisbTaxExempt:
            case DisbursementFields.DisbTaxable:
            case DisbursementFields.DisbTax:
            case DisbursementFields.Posted:
            case DisbursementFields.Final:
                if (dr.Final)
                {
                    throw new AtriumException(Resources.DisbNoEditAfterCommit);
                }
                break;

            case DisbursementFields.Taxed:
                if (!dr.Final && dr.Taxed)
                {
                    throw new AtriumException(Resources.DisbNoTaxUnlessCommit);
                }
                break;

            default:
                break;
            }
        }
コード例 #5
0
        protected override void BeforeChange(DataColumn dc, DataRow ddr)
        {
            atriumDB.ActivityBFRow dr = (atriumDB.ActivityBFRow)ddr;
            switch (dc.ColumnName)
            {
            case "Completed":
            case "Priority":
            case "isRead":
            case "BFComment":
            case "BFDate":
                if (dr.RowState != DataRowState.Added && !CanEditBF(dr))
                {
                    throw new ReadOnlyException();
                }
                break;
            }

            switch (dc.ColumnName)
            {
            case "ManuallyCompleted":
                //only allow manual completion for user and mail bfs that are marked as allow manual complete
                ActivityConfig.ACBFRow neml = (ActivityConfig.ACBFRow)myA.AtMng.acMng.DB.ACBF.FindByACBFId(dr.ACBFId);
                if (neml.AllowManualComplete)
                {     //ok
                }
                else
                {
                    //   if(dr.ManuallyCompleted)
                    bool canOverride = myA.AtMng.SecurityManager.CanOverride(dr.FileId, atSecurity.SecurityManager.Features.ActivityBF) == atSecurity.SecurityManager.ExPermissions.Yes;
                    if (!canOverride)
                    {
                        throw new AtriumException("You cannot manually complete this type of BF.");
                    }
                }

                break;

            case "BFType":
                if (dr.IsBFTypeNull())
                {
                    throw new RequiredException(dc.ColumnName);
                }
                else if (!myA.CheckDomain(dr.BFType, myA.Codes("BFType")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, "BF Type", "Activity BF", "BF Type");
                }
                break;

            case "ACBFId":
                if (!myA.CheckDomain(dr.ACBFId, myA.AtMng.acMng.DB.ACBF))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "ACBF");
                }
                break;

            case "ForOfficeId":
                if (!myA.CheckDomain(dr.ForOfficeId, myA.Codes("OfficeList")))
                {
                    throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "Office List");
                }
                break;

            case ActivityFields.BFOfficerID:
                if (!dr.IsBFOfficerIDNull())
                {
                    if (!myA.CheckDomain(dr.BFOfficerID, myA.Codes("OfficerList")))
                    {
                        throw new AtriumException(atriumBE.Properties.Resources.BadDomainValue, dc.ColumnName, dr.Table.TableName, "Officer List");
                    }
                }
                break;

            //case ActivityBFFields.ForOfficeId:
            //    if (!myA.AtMng.GetOffice(dr.ForOfficeId).CurrentOffice.IsOnLine)
            //        throw new AtriumException(Resources.ActivityBFCannotBeCreatedForAnOffLineOffice);
            //    break;
            case ActivityFields.BFDate:
                if (dr.IsBFDateNull())
                {
                    throw new RequiredException(ActivityFields.BFDate);
                }
                if (!dr.IsBFDateNull())
                {
                    myA.IsValidDate(Resources.ActivityBFBFDate, dr.BFDate, true, DebtorBE.CSLBegin, DateTime.Today.AddYears(30), Resources.ValidationCSLBegin, Resources.ValidationThirtyYearsLater);
                }
                break;
            }
        }