protected virtual IEnumerable selectedItems()
        {
            EMailAccountSyncFilter filter = Filter.Current;

            BqlCommand cmd = SelectedItems.View.BqlSelect;

            if (filter != null && filter.ServerID != null)
            {
                cmd = cmd.WhereAnd <Where <EMailSyncAccount.serverID, Equal <Current <EMailAccountSyncFilter.serverID> > > >();
            }
            if (filter != null && !String.IsNullOrEmpty(filter.PolicyName))
            {
                cmd = cmd.WhereAnd <Where <EMailSyncAccount.policyName, Equal <Current <EMailAccountSyncFilter.policyName> > > >();
            }

            int    totalRows = 0;
            int    startRow  = PXView.StartRow;
            PXView view      = new PXView(this, false, cmd); view.Clear( );

            foreach (PXResult <EMailSyncAccount, EMailSyncServer, EPEmployee, Contact> item in
                     view.Select(PXView.Currents, PXView.Parameters, PXView.Searches, PXView.SortColumns, PXView.Descendings, PXView.Filters, ref startRow, PXView.MaximumRows, ref totalRows))
            {
                Contact          contact = item;
                EMailSyncAccount account = item;
                account.Address = (contact != null ? contact.EMail : null) ?? account.Address;

                //SelectedItems.Cache.SetStatus(account, PXEntryStatus.Notchanged);

                yield return(item);
            }
        }
        public override void Record_RowPersisting(PXCache sender, PXRowPersistingEventArgs e)
        {
            if ((e.Operation & PXDBOperation.Command) == PXDBOperation.Insert && ((FSAddress)e.Row).IsDefaultAddress == true)
            {
                PXView view = sender.Graph.TypedViews.GetView(_DuplicateSelect, true);
                view.Clear();

                FSAddress previousAddress = (FSAddress)view.SelectSingle(((FSAddress)e.Row).BAccountID, ((FSAddress)e.Row).BAccountAddressID, ((FSAddress)e.Row).RevisionID);

                if (previousAddress != null)
                {
                    _KeyToAbort = sender.GetValue(e.Row, _RecordID);
                    object newKey = sender.Graph.Caches[typeof(FSAddress)].GetValue(previousAddress, _RecordID);

                    PXCache cache = sender.Graph.Caches[_ItemType];

                    foreach (object data in cache.Updated)
                    {
                        object dataKey = cache.GetValue(data, _FieldOrdinal);

                        if (Equals(_KeyToAbort, dataKey))
                        {
                            cache.SetValue(data, _FieldOrdinal, newKey);
                        }
                    }

                    _KeyToAbort = null;
                    e.Cancel    = true;
                    return;
                }
            }

            base.Record_RowPersisting(sender, e);
        }
示例#3
0
        public override void SetCurrentYearSetup(object[] key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            if (key.Length < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(key));
            }
            if (key[0] == null)
            {
                throw new ArgumentNullException(nameof(key));
            }

            int bookID = (int)key[0];

            // TODO: Refactor to call FABookPeriodRepository.FindFABookYearSetup
            PXView view = new PXView(
                this,
                false,
                new Select <
                    FABookYearSetup,
                    Where <FABookYearSetup.bookID, Equal <Required <FABook.bookID> > > >());

            view.Clear();

            FiscalYearSetup.Current = FiscalYearSetup.Current ?? view.SelectSingle(bookID) as FABookYearSetup;
        }
示例#4
0
        public static PXView CreateView(this BqlCommand command, PXGraph graph, bool clearQueryCache = false, bool mergeCache = false)
        {
            PXView view = new PXView(graph, !mergeCache, command);

            if (clearQueryCache)
            {
                view.Clear();
            }
            return(view);
        }
        public IYearSetup FindFABookYearSetup(FABook book, bool clearQueryCache = false)
        {
            BqlCommand selectCommand;

            if (book.UpdateGL == true)
            {
                selectCommand = new Select <FinYearSetup>();
            }
            else
            {
                selectCommand = new Select <
                    FABookYearSetup,
                    Where <FABookYearSetup.bookID, Equal <Required <FABook.bookID> > > >();
            }
            PXView view = new PXView(Graph, true, selectCommand);

            if (clearQueryCache)
            {
                view.Clear();
            }
            return(view.SelectSingle(book.BookID) as IYearSetup);
        }
        public override void RowPersisting(PXCache sender, PXRowPersistingEventArgs e)
        {
            object key = sender.GetValue(e.Row, _FieldOrdinal);

            if (key != null)
            {
                PXCache cache = sender.Graph.Caches[_RecordType];

                if (Convert.ToInt32(key) < 0)
                {
                    foreach (object data in cache.Inserted)
                    {
                        object dataKey = cache.GetValue(data, _RecordID);

                        if (Equals(key, dataKey))
                        {
                            if (((FSAddress)data).IsDefaultAddress == true)
                            {
                                PXView view = sender.Graph.TypedViews.GetView(_DuplicateSelect, true);
                                view.Clear();

                                FSAddress previousAddress = (FSAddress)view.SelectSingle(((FSAddress)data).BAccountID, ((FSAddress)data).BAccountAddressID, ((FSAddress)data).RevisionID);

                                if (previousAddress != null)
                                {
                                    _KeyToAbort = sender.GetValue(e.Row, _FieldOrdinal);
                                    object id = sender.Graph.Caches[typeof(FSAddress)].GetValue(previousAddress, _RecordID);
                                    sender.SetValue(e.Row, _FieldOrdinal, id);
                                }
                            }

                            break;
                        }
                    }
                }
            }

            base.RowPersisting(sender, e);
        }
        public IEnumerable <IPeriodSetup> FindFABookPeriodSetup(FABook book, bool clearQueryCache = false)
        {
            BqlCommand selectCommand;

            if (book.UpdateGL == true)
            {
                selectCommand = new Select3 <FinPeriodSetup, OrderBy <Asc <FinPeriodSetup.periodNbr> > >();
            }
            else
            {
                selectCommand = new Select <
                    FABookPeriodSetup,
                    Where <FABookPeriodSetup.bookID, Equal <Required <FABook.bookID> > >,
                    OrderBy <Asc <FABookPeriodSetup.periodNbr> > >();
            }
            PXView view = new PXView(Graph, true, selectCommand);

            if (clearQueryCache)
            {
                view.Clear();
            }
            return(view.SelectMulti(book.BookID).Cast <IPeriodSetup>());
        }
示例#8
0
        private static void ProcessValidation(ValidationFilter Filter, Contact record)
        {
            PXPrimaryGraphCollection primaryGraph = new PXPrimaryGraphCollection(new PXGraph());
            PXGraph graph = primaryGraph[record];

            if (graph == null)
            {
                throw new PXException(Messages.UnableToFindGraph);
            }

            PXView        view = graph.Views[graph.PrimaryView];
            int           startRow = 0, totalRows = 0;
            List <object> list_contact = view.Select(null, null, new object[] { record.ContactID }, new string[] { typeof(Contact.contactID).Name }, null, null,
                                                     ref startRow, 1, ref totalRows);

            if (list_contact == null || list_contact.Count < 1)
            {
                throw new PXException(Messages.ContactNotFound);
            }
            Contact contact = PXResult.Unwrap <Contact>(list_contact[0]);

            contact.DuplicateFound = true;
            //Find duplicates view
            PXView viewDuplicates = graph.Views.ToArray().First(v => v.Value.Cache.GetItemType() == typeof(CRDuplicateRecord)).Value;

            if (viewDuplicates == null)
            {
                throw new PXException(Messages.DuplicateViewNotFound);
            }
            viewDuplicates.Clear();
            List <object> duplicates = viewDuplicates.SelectMulti();

            contact = (Contact)view.Cache.CreateCopy(contact);
            string prevStatus = contact.DuplicateStatus;

            contact.DuplicateStatus = DuplicateStatusAttribute.Validated;
            Decimal?score = 0;

            contact.DuplicateFound = duplicates.Count > 0;
            foreach (PXResult <CRDuplicateRecord, Contact, Contact2> r in duplicates)
            {
                Contact2          duplicate    = r;
                CRDuplicateRecord contactScore = r;
                int duplicateWeight            = ContactMaint.GetContactWeight(duplicate);
                int currentWeight = ContactMaint.GetContactWeight(contact);

                if (duplicateWeight > currentWeight ||
                    (duplicateWeight == currentWeight &&
                     duplicate.ContactID < contact.ContactID))
                {
                    contact.DuplicateStatus = DuplicateStatusAttribute.PossibleDuplicated;
                    if (contactScore.Score > score)
                    {
                        score = contactScore.Score;
                    }
                }
            }
            view.Cache.Update(contact);

            if (contact.DuplicateStatus == DuplicateStatusAttribute.PossibleDuplicated &&
                contact.ContactType == ContactTypesAttribute.Lead &&
                contact.Status == LeadStatusesAttribute.New &&
                Filter.CloseNoActivityLeads == true &&
                score > Filter.CloseThreshold)
            {
                CRActivity activity = PXSelect <CRActivity,
                                                Where <CRActivity.contactID, Equal <Required <Contact.contactID> > > > .SelectWindowed(graph, 0, 1, contact.ContactID);

                if (activity == null)
                {
                    PXAction  action  = graph.Actions["Action"];
                    PXAdapter adapter = new PXAdapter(view);
                    adapter.StartRow    = 0;
                    adapter.MaximumRows = 1;
                    adapter.Searches    = new object[] { contact.ContactID };
                    adapter.Menu        = Messages.CloseAsDuplicate;
                    adapter.SortColumns = new[] { typeof(Contact.contactID).Name };
                    foreach (Contact c in action.Press(adapter))
                    {
                        ;
                    }
                    prevStatus = null;
                }
            }
            view.Cache.RestoreCopy(record, view.Cache.Current);
            if (prevStatus != contact.DuplicateStatus)
            {
                graph.Actions.PressSave();
            }
        }
示例#9
0
        private static void ProcessValidation(ValidationFilter filter, Contact record)
        {
            BusinessAccountMaint graph = PXGraph.CreateInstance <BusinessAccountMaint>();
            PXView view = graph.BAccount.View;

            int startRow = 0, totalRows = 0;

            BAccount baccount = null;
            Contact  contact  = null;

            if (record.ContactType == ContactTypesAttribute.BAccountProperty && record.BAccountID != null)
            {
                List <object> list_baccount = view.Select(null, null, new object[] { record.BAccountID }, new string[] { typeof(BAccount.bAccountID).Name }, null, null,
                                                          ref startRow, 1, ref totalRows);
                if (list_baccount != null && list_baccount.Count >= 1)
                {
                    baccount = PXResult.Unwrap <BAccount>(list_baccount[0]);
                }
            }
            if (baccount == null || baccount.DefContactID != record.ContactID)
            {
                throw new PXException(Messages.ContactNotFound);
            }

            contact = graph.DefContact.Current = graph.DefContact.SelectWindowed(0, 1);
            contact.DuplicateFound = true;

            PXView viewDuplicates = graph.Duplicates.View;

            if (viewDuplicates == null)
            {
                throw new PXException(Messages.DuplicateViewNotFound);
            }
            viewDuplicates.Clear();
            List <object> duplicates = viewDuplicates.SelectMulti();

            contact = (Contact)graph.DefContact.Cache.CreateCopy(contact);
            contact.DuplicateStatus = DuplicateStatusAttribute.Validated;
            Decimal?score = 0;

            foreach (PXResult <CRDuplicateRecord, Contact, CRLeadContactValidationProcess.Contact2> r in duplicates)
            {
                CRLeadContactValidationProcess.Contact2 duplicate = r;
                CRDuplicateRecord contactScore = r;

                int duplicateWeight = ContactMaint.GetContactWeight(duplicate);
                int currentWeight   = ContactMaint.GetContactWeight(contact);
                if (duplicateWeight > currentWeight ||
                    (duplicateWeight == currentWeight &&
                     duplicate.ContactID < contact.ContactID))
                {
                    contact.DuplicateStatus = DuplicateStatusAttribute.PossibleDuplicated;
                    if (contactScore.Score > score)
                    {
                        score = contactScore.Score;
                    }
                }
            }
            graph.DefContact.Cache.Update(contact);
            graph.DefContact.Cache.RestoreCopy(record, contact);
            graph.Actions.PressSave();
        }
示例#10
0
 private void ResetView(PXView view)
 {
     view.Cache.Current = null;
     view.Clear();
 }