private static PXView CreateRestictedIntView(PXGraph graph) { Type inventoryID = GetTypeField <Status>(typeof(INSiteStatus.inventoryID).Name); Type subItemID = GetTypeField <Status>(typeof(INSiteStatus.subItemID).Name); Type siteID = GetTypeField <Status>(typeof(INSiteStatus.siteID).Name); Type join = BqlCommand.Compose( typeof(InnerJoin <,>), typeof(RQRequestClassItem), typeof(On <, ,>), typeof(RQRequestClassItem.inventoryID), typeof(Equal <>), inventoryID, typeof(And <RQRequestClassItem.reqClassID, Equal <Current <RQRequestClass.reqClassID> > >)); Type where = CreateWhere(graph); Type selectType = BqlCommand.Compose( typeof(Select2 <, ,>), typeof(Status), join, where); return(new LookupView(graph, BqlCommand.CreateInstance(selectType))); }
public override void CacheAttached(PXCache sender) { if (sender.Graph.GetType() == typeof(AttrGraph)) { return; } if (sender.Graph.GetType() == typeof(PXGraph) || sender.Graph.GetType() == typeof(PX.Data.Maintenance.GI.GenericInquiryDesigner)) { _IsActive = true; } base.CacheAttached(sender); InitializeFields(sender); Type selectType = _SingleSelect.GetType(); Type itemType = sender.GetItemType(); while (itemType != typeof(object) && selectType == _SingleSelect.GetType()) { selectType = BqlCommand.Parametrize(itemType, selectType); itemType = itemType.BaseType; } _View = new PXView(sender.Graph, true, BqlCommand.CreateInstance(selectType)); }
public virtual IEnumerable records(PXAdapter adapter) { Type where = PX.TM.OwnedFilter.ProjectionAttribute.ComposeWhere( typeof(POPrintOrderFilter), typeof(POPrintOrderOwned.workgroupID), typeof(POPrintOrderOwned.ownerID)); Type printWhere = typeof(Where <POPrintOrderOwned.hold, Equal <False>, And <POPrintOrderOwned.dontPrint, Equal <False>, And <POPrintOrderOwned.printed, NotEqual <True> > > >); Type emailWhere = typeof(Where <POPrintOrderOwned.hold, Equal <False>, And <POPrintOrderOwned.dontEmail, Equal <False>, And <POPrintOrderOwned.emailed, NotEqual <True> > > >); Type action = Filter.Current.Action == "<SELECT>" ? typeof(Where <CS.boolTrue, Equal <CS.boolFalse> >) : Filter.Current.Action.Contains("Email") ? emailWhere : printWhere; Type select = BqlCommand.Compose( typeof(Select2 <, ,>), typeof(POPrintOrderOwned), typeof(InnerJoin <Vendor, On <Vendor.bAccountID, Equal <POPrintOrderOwned.vendorID> >, LeftJoin <EPEmployee, On <EPEmployee.bAccountID, Equal <POPrintOrderOwned.employeeID> > > >), typeof(Where <>), action); PXView view = new PXView(this, false, BqlCommand.CreateInstance(select)); return(view.SelectMulti()); }
private bool IsItemRuleTrue(IBqlTable item, EPAssignmentRule rule) { if (item is EPEmployee && rule.FieldName.Equals(typeof(EPEmployee.workgroupID).Name, StringComparison.InvariantCultureIgnoreCase)) { return(IsEmployeeInWorkgroup((EPEmployee)item, rule)); } currentItem = item; Type viewType = BqlCommand.Compose(typeof(Select <>), item.GetType()); PXView itemView = new PXView(this, false, BqlCommand.CreateInstance(viewType), (PXSelectDelegate)getItemRecord); if (rule.Condition == null) { return(false); } PXFilterRow filter = new PXFilterRow( rule.FieldName, (PXCondition)rule.Condition.Value, GetFieldValue(item, rule.FieldName, rule.FieldValue), null); int startRow = 0; int totalRows = 0; List <object> result = itemView.Select(null, null, null, null, null, new PXFilterRow[] { filter }, ref startRow, 1, ref totalRows); return(result.Count > 0); }
protected override BqlCommand AddCaseLimitations(BqlCommand command) { var res = base.AddCaseLimitations(command); return(res.WhereAnd(typeof(Where2 <Where <SimpleCase.closed, Equal <False>, Or <SimpleCase.closed, IsNull> >, And <Where <SimpleCase.released, Equal <False>, Or <SimpleCase.released, IsNull> > > >))); }
public static void NewChild(PXCache cache, object parentrow, Type ParentType, out object child) { foreach (PXEventSubscriberAttribute attr in cache.GetAttributes(null)) { if (attr is PXParentAttribute && ((PXParentAttribute)attr).ParentType.IsAssignableFrom(ParentType)) { Type childType = cache.GetItemType(); PXView parentView = ((PXParentAttribute)attr).GetParentSelect(cache); Type parentType = parentView.BqlSelect.GetFirstTable(); PXView childView = ((PXParentAttribute)attr).GetChildrenSelect(cache); BqlCommand selectChild = childView.BqlSelect; IBqlParameter[] pars = selectChild.GetParameters(); Type[] refs = selectChild.GetReferencedFields(false); child = Activator.CreateInstance(childType); PXCache parentcache = cache.Graph.Caches[parentType]; for (int i = 0; i < Math.Min(pars.Length, refs.Length); i++) { Type partype = pars[i].GetReferencedType(); object val = parentcache.GetValue(parentrow, partype.Name); cache.SetValue(child, refs[i].Name, val); } return; } } child = null; }
public static string MakeDescription <TField>(this PXGraph graph, string originalDescription, DescriptionMaker maker) where TField : IBqlField { string generatedDescription = maker(originalDescription); int maxDescriptionLength = 0; graph.Caches[BqlCommand.GetItemType <TField>()].Adjust <PXDBStringAttribute>().For <TField>(attribute => maxDescriptionLength = attribute?.Length ?? -1); if (maxDescriptionLength == -1) // PXDBStringAttribute not found, cutting is not needed { return(generatedDescription); } int delta = generatedDescription.Length - maxDescriptionLength; if (delta > 0) // cutting is needed { if (delta > originalDescription.Length) { throw new PXException(Messages.DescriptionCannotBeGenerated, maxDescriptionLength, typeof(TField).FullName, originalDescription, generatedDescription); } generatedDescription = maker(originalDescription.Substring(0, originalDescription.Length - delta)); } return(generatedDescription); }
protected virtual IEnumerable GetRecords() { PXCache cache = _Graph.Caches[_CacheType]; object extCurrentRow = PXView.Currents.FirstOrDefault(c => _CacheType.IsAssignableFrom(c.GetType())); FABookPeriod.Key periodKey = ReportParametersMask != ReportParametersFlag.None ? BookPeriodKeyProvider.GetKeyFromReportParameters(_Graph, PXView.Parameters, ReportParametersMask) : BookPeriodKeyProvider.GetKey(_Graph, cache, extCurrentRow); int startRow = PXView.StartRow; int totalRows = 0; List <object> parameters = new List <object>(); BqlCommand cmd = GetCommand(cache, extCurrentRow, parameters, periodKey); PXView view = new PXView(_Graph, PXView.View?.IsReadOnly ?? true, cmd); try { return(view.Select(PXView.Currents, parameters.ToArray(), PXView.Searches, PXView.SortColumns, PXView.Descendings, PXView.Filters, ref startRow, PXView.MaximumRows, ref totalRows)); } finally { PXView.StartRow = 0; } }
public void FieldDefaulting(PXCache sender, PXFieldDefaultingEventArgs e) { EPEmployee employee = null; if (employeeSearch != null) { BqlCommand cmd = BqlCommand.CreateInstance(employeeSearch); PXView view = new PXView(sender.Graph, false, cmd); employee = view.SelectSingle() as EPEmployee; } if (employee != null && !string.IsNullOrEmpty(employee.UnionID)) { HashSet <string> validUnions = new HashSet <string>(); if (projectField != null) { int?projectID = (int?)sender.GetValue(e.Row, projectField.Name); if (ProjectDefaultAttribute.IsProject(sender.Graph, projectID)) { var select = new PXSelect <PMProjectUnion, Where <PMProjectUnion.projectID, Equal <Required <PMProjectUnion.projectID> > > >(sender.Graph); foreach (PMProjectUnion union in select.Select(projectID)) { validUnions.Add(union.UnionID); } } } if (validUnions.Count == 0 || validUnions.Contains(employee.UnionID)) { e.NewValue = employee.UnionID; } } }
protected virtual IEnumerable filter() { ApproveBillsFilter filter = Filter.Current; if (filter != null && filter.SelectionDate != null) { DateTime PayInLessThan = ((DateTime)filter.SelectionDate).AddDays(filter.PayInLessThan.GetValueOrDefault()); DateTime DueInLessThan = ((DateTime)filter.SelectionDate).AddDays(filter.DueInLessThan.GetValueOrDefault()); DateTime DiscountExpiresInLessThan = ((DateTime)filter.SelectionDate).AddDays(filter.DiscountExpiresInLessThan.GetValueOrDefault()); decimal approvedTotal = 0m; decimal docsTotal = 0m; PXView view = new PXView(this, true, BqlCommand.CreateInstance(getAPDocumentSelect(true))); foreach (PXResult <APInvoice> temp in view.SelectMulti(PayInLessThan, DueInLessThan, DiscountExpiresInLessThan)) { APInvoice res = temp; approvedTotal += res.PaySel == true ? (Accessinfo.CuryViewState ? (res.DocBal ?? 0m) : (res.CuryDocBal ?? 0m)) : 0m; docsTotal += Accessinfo.CuryViewState ? (res.DocBal ?? 0m) : (res.CuryDocBal ?? 0m); } Filter.Current.CuryApprovedTotal = approvedTotal; Filter.Current.CuryDocsTotal = docsTotal; yield return(Filter.Current); Filter.Cache.IsDirty = false; } }
protected override Type GetSearchType(Type projectId) { return(BqlCommand.Compose(typeof(Search <,>), typeof(PMTask.taskID), typeof(Where <, ,>), typeof(PMTask.projectID), typeof(Equal <>), typeof(Optional <>), projectId, typeof(And <PMTask.type, NotEqual <ProjectTaskType.revenue>, And <PMTask.status, In3 <ProjectTaskStatus.active, ProjectTaskStatus.planned> > >))); }
protected override List <PXResult <CSAnswers, CSAttributeGroup, InventoryItem> > SelectInventoryWithAttributes() { Type sumDecimalFields = BqlCommand.Compose(BqlHelper.GetDecimalFieldsAggregate <INSiteStatus>(Base, true).ToArray()); Type select = BqlTemplate.OfCommand < Select5 <CSAnswers, InnerJoin <CSAttributeGroup, On <CSAnswers.attributeID, Equal <CSAttributeGroup.attributeID> >, InnerJoin <InventoryItem, On <CSAnswers.refNoteID, Equal <InventoryItem.noteID>, And <CSAttributeGroup.entityClassID, Equal <InventoryItem.itemClassID> > >, LeftJoin <INSiteStatus, On <INSiteStatus.inventoryID, Equal <InventoryItem.inventoryID>, And <INSiteStatus.subItemID, Equal <InventoryItem.defaultSubItemID>, And <Where <INSiteStatus.siteID, Equal <Current <EntryHeader.siteID> >, Or <Current <EntryHeader.siteID>, IsNull> > > > >, LeftJoin <INLocationStatus, On <INLocationStatus.inventoryID, Equal <InventoryItem.inventoryID>, And <INLocationStatus.subItemID, Equal <InventoryItem.defaultSubItemID>, And <INLocationStatus.siteID, Equal <Current <EntryHeader.siteID> >, And <INLocationStatus.locationID, Equal <Current <EntryHeader.locationID> > > > > > > > > >, Where <CSAttributeGroup.isActive, Equal <True>, And <CSAttributeGroup.entityType, Equal <Constants.DACName <InventoryItem> >, And <CSAttributeGroup.attributeCategory, Equal <CSAttributeGroup.attributeCategory.variant>, And <InventoryItem.templateItemID, Equal <Current <EntryHeader.templateItemID> > > > > >, Aggregate <GroupBy <InventoryItem.inventoryID, GroupBy <CSAnswers.refNoteID, GroupBy <CSAnswers.attributeID, BqlPlaceholder.A> > > >, OrderBy <Asc <InventoryItem.inventoryID, Asc <CSAnswers.refNoteID, Asc <CSAnswers.attributeID> > > > > > .Replace <BqlPlaceholder.A>(sumDecimalFields) .ToType(); var view = new PXView(Base, true, BqlCommand.CreateInstance(select)); using (new PXFieldScope(view, typeof(InventoryItem.inventoryID), typeof(CSAnswers.attributeID), typeof(CSAnswers.value), typeof(INSiteStatus), typeof(INLocationStatus))) { return(view.SelectMulti().Cast <PXResult <CSAnswers, CSAttributeGroup, InventoryItem> >().ToList()); } }
public static Type GetSearchType(Type origSearchType, ReportParametersFlag reportParametersMask) { //params will be passed into GetRecords context if they will be parsed from the query if (reportParametersMask != ReportParametersFlag.None) { BqlCommand cmd = BqlCommand.CreateInstance(origSearchType); if ((reportParametersMask & ReportParametersFlag.Organization) == ReportParametersFlag.Organization) { cmd = cmd.WhereAnd <Where <FABookPeriod.organizationID, Equal <Optional2 <FAQueryParameters.organizationID> > > >(); } if ((reportParametersMask & ReportParametersFlag.Branch) == ReportParametersFlag.Branch) { cmd = cmd.WhereAnd <Where <FABookPeriod.organizationID, Equal <Optional2 <FAQueryParameters.branchID> > > >(); } if ((reportParametersMask & ReportParametersFlag.BAccount) == ReportParametersFlag.BAccount) { cmd = cmd.WhereAnd <Where <FABookPeriod.organizationID, Equal <Optional2 <FAQueryParameters.orgBAccountID> > > >(); } if ((reportParametersMask & ReportParametersFlag.FixedAsset) == ReportParametersFlag.FixedAsset) { cmd = cmd.WhereAnd <Where <FABookPeriod.organizationID, Equal <Optional2 <FAQueryParameters.assetID> > > >(); } if ((reportParametersMask & ReportParametersFlag.Book) == ReportParametersFlag.Book) { cmd = cmd.WhereAnd <Where <FABookPeriod.bookID, Equal <Optional2 <FAQueryParameters.bookID> > > >(); } return(cmd.GetType()); } return(origSearchType); }
/// public PXDBAttributeAttribute(Type valueSearch, Type attributeID) { if (valueSearch == null) { throw new PXArgumentException("type", ErrorMessages.ArgumentNullException); } if (attributeID == null) { throw new PXArgumentException("field", ErrorMessages.ArgumentNullException); } _Field = attributeID; if (typeof(IBqlSearch).IsAssignableFrom(valueSearch)) { _SingleSelect = BqlCommand.CreateInstance(valueSearch); } else if (valueSearch.IsNested && typeof(IBqlField).IsAssignableFrom(valueSearch)) { _SingleSelect = BqlCommand.CreateInstance(typeof(Search <>), valueSearch); } else { throw new PXArgumentException(nameof(valueSearch), ErrorMessages.CantCreateForeignKeyReference, valueSearch); } _PureWhere = (_SingleSelect as IHasBqlWhere).GetWhere(); _SubSelect = _SingleSelect.WhereAnd(typeof(Where <,>).MakeGenericType(_Field, typeof(Equal <AttributeIDPlaceholder>))); _SingleSelect = _SingleSelect.WhereAnd(BqlCommand.Compose(typeof(Where <,>), _Field, typeof(Equal <>), typeof(Required <>), _Field)); }
protected virtual Type GetBQLStatement() { Type where = PX.TM.OwnedFilter.ProjectionAttribute.ComposeWhere( typeof(ARTwilioNotificationProcessFilter), typeof(ARInvoice.workgroupID), typeof(ARInvoice.ownerID)); Type Where = typeof(Where <ARInvoice.hold, Equal <False>, And <ARInvoice.released, Equal <True>, And <ARInvoice.voided, Equal <False>, And <ARInvoice.docType, Equal <ARInvoiceType.invoice>, And <ARInvoice.curyDocBal, Greater <decimal0>, And <ARInvoice.docDate, LessEqual <Current <ARTwilioNotificationProcessFilter.endDate> >, And <ARInvoice.docDate, GreaterEqual <Current <ARTwilioNotificationProcessFilter.beginDate> > > > > > > > >); Type whereAnd; whereAnd = Filter.Current.Action == "<SELECT>" ? typeof(Where <True, Equal <False> >) : Where; Type select = BqlCommand.Compose( typeof(Select2 <, ,>), typeof(ARInvoice), typeof(InnerJoinSingleTable <Customer, On <Customer.bAccountID, Equal <ARInvoice.customerID> > >), typeof(Where2 <,>), typeof(Match <Customer, Current <AccessInfo.userName> >), typeof(And2 <,>), whereAnd, typeof(And <>), where); return(select); }
private void ParseOperand(PXGraph graph, List <IBqlParameter> pars, List <Type> tables, List <Type> fields, List <IBqlSortColumn> sortColumns, StringBuilder text, PX.Data.BqlCommand.Selection selection) { BqlCommand.EqualityList list = fields as BqlCommand.EqualityList; if (list != null) { list.NonStrict = true; } if (!typeof(IBqlCreator).IsAssignableFrom(typeof(Operand))) { if (graph != null && text != null) { text.Append(" ").Append(BqlCommand.GetSingleField(typeof(Operand), graph, tables, selection)); } if (fields != null) { fields.Add(typeof(Operand)); } } else { if (_operand == null) { _operand = _operand.createOperand <Operand>(); } _operand.Parse(graph, pars, tables, fields, sortColumns, text, selection); } }
public IsSchedulable() { Dictionary <string, Type> fields = typeof(TRegister) .GetNestedTypes() .ToDictionary(nestedTypes => nestedTypes.Name); Type releasedField = fields[nameof(APRegister.released)]; Type prebookedField = fields[nameof(APRegister.prebooked)]; Type holdField = fields[nameof(APRegister.hold)]; Type voidedField = fields[nameof(APRegister.voided)]; Type rejectedField = fields[nameof(APRegister.rejected)]; Type origModuleField = fields[nameof(APRegister.origModule)]; Type isMigratedRecordField = fields[nameof(APRegister.isMigratedRecord)]; Type createdByScreenIdField = fields[nameof(APRegister.createdByScreenID)]; Type docTypeField = fields[nameof(APRegister.docType)]; Type refNbrField = fields[nameof(APRegister.refNbr)]; Type noteIdField = fields[nameof(APRegister.noteID)]; Type whereType = BqlCommand.Compose( typeof(Where <, ,>), releasedField, typeof(Equal <>), typeof(False), typeof(And <, ,>), prebookedField, typeof(Equal <>), typeof(False), typeof(And <, ,>), holdField, typeof(Equal <>), typeof(False), typeof(And <, ,>), voidedField, typeof(Equal <>), typeof(False), typeof(And <, ,>), rejectedField, typeof(Equal <>), typeof(False), typeof(And <, ,>), origModuleField, typeof(Equal <>), typeof(BatchModule.moduleAP), typeof(And <, ,>), isMigratedRecordField, typeof(Equal <>), typeof(False), typeof(And2 <,>), typeof(Not <>), typeof(IsPOLinked <,>), docTypeField, refNbrField, typeof(And <>), typeof(Not <>), typeof(ExistsJournalVoucher <>), noteIdField); where = Activator.CreateInstance(whereType) as IBqlUnary; }
private static Dictionary <string, string> GetFieldNamesAndValues(BqlCommand command) { Dictionary <string, string> dic = new Dictionary <string, string>(); bool isFirstTable = true; PXUIFieldAttribute currentAttribute; string currentValue; foreach (Type item in command.GetTables()) { foreach (System.Reflection.PropertyInfo field in item.GetProperties()) { currentAttribute = Attribute.GetCustomAttribute(field, typeof(PXUIFieldAttribute), true) as PXUIFieldAttribute; if (currentAttribute != null && currentAttribute.Filterable) { currentValue = string.Format(isFirstTable ? "{0}__{1}" : "{0}.{1}", item.Name, field.Name); if (!string.IsNullOrEmpty(currentAttribute.DisplayName)) { dic.Add(currentValue, currentAttribute.DisplayName); } else { dic.Add(currentValue, currentValue); } } } isFirstTable = false; } return(dic); }
private void SaveAs(bool onlyUpdate) { if (Templates.Current != null) { BqlCommand command = BqlCommand.CreateInstance(typeof(Select <CRFilterTemplate, Where <CRFilterTemplate.name, Equal <Current <CRFilterTemplate.name> >, And <CRFilterTemplate.graphType, Equal <Required <CRFilterTemplate.graphType> > > > >)); CRFilterTemplate templateToUpdate = (new PXView(this, true, command)).SelectSingle(graphTypeName) as CRFilterTemplate; if (onlyUpdate && templateToUpdate == null) { return; } if (templateToUpdate == null) { InsertNewTemplate(); } else { UpdateExistingTemplate(templateToUpdate); } CorrectGraphType(); CorrectDefaultValues(); SafetyPersist(Templates.Cache, PXDBOperation.Insert, PXDBOperation.Update); SafetyPersist(Filters.Cache, PXDBOperation.Delete, PXDBOperation.Insert, PXDBOperation.Update); Filters.Cache.Clear(); Templates.Cache.Clear(); Templates.View.RequestRefresh(); } }
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 CacheAttached(PXCache sender) { base.CacheAttached(sender); if (MasterFinPeriodIDType != null) { sender.Graph.FieldDefaulting.AddHandler(sender.GetItemType(), MasterFinPeriodIDType.Name, MasterFinPeriodIDFieldDefaulting); } if (UseMasterCalendarSourceType != null) { if (OrganizationSourceType != null) { sender.Graph.FieldUpdated.AddHandler( BqlCommand.GetItemType(OrganizationSourceType), OrganizationSourceType.Name, CalendarOrganizationIDSourceFieldUpdated); } if (BranchSourceType != null) { sender.Graph.FieldUpdated.AddHandler( BqlCommand.GetItemType(BranchSourceType), BranchSourceType.Name, CalendarOrganizationIDSourceFieldUpdated); } } }
/// <summary> /// Returns all searchable fields including dependent fields and key fields. /// Ex: Since Contact.DisplayName depends on FirstName, LastName, etc. all these fields will also be returned. /// </summary> /// <returns></returns> public ICollection <Type> GetSearchableFields(PXCache cache) { HashSet <Type> result = new HashSet <Type>(); foreach (Type item in titleFields.Union(fields)) { result.Add(item); foreach (Type dependable in PXDependsOnFieldsAttribute.GetDependsRecursive(cache, item.Name).Select(cache.GetBqlField)) { result.Add(dependable); } //Note: Keys can be removed once 43383 is resolved. Type dacType = BqlCommand.GetItemType(item); foreach (Type key in cache.Graph.Caches[dacType].BqlKeys) { result.Add(key); } } if (WhereConstraint != null) { foreach (Type type in BqlCommand.Decompose(WhereConstraint)) { if ((typeof(IBqlField)).IsAssignableFrom(type)) { result.Add(type); } } } return(result); }
public ContractAttribute(Type WhereType) { Type SearchType = BqlCommand.Compose( typeof(Search2 <, , ,>), typeof(Contract.contractID), typeof(InnerJoin <ContractBillingSchedule, On <ContractBillingSchedule.contractID, Equal <Contract.contractID> > >), typeof(Where <, ,>), typeof(Contract.isTemplate), typeof(Equal <boolFalse>), typeof(And <, ,>), typeof(Contract.baseType), typeof(Equal <>), typeof(Contract.ContractBaseType), typeof(And <>), WhereType, typeof(OrderBy <Desc <Contract.contractCD> >)); PXDimensionSelectorAttribute select = new PXDimensionSelectorAttribute(DimensionName, SearchType, typeof(Contract.contractCD), typeof(Contract.contractCD), typeof(Contract.customerID), typeof(Contract.locationID), typeof(Contract.description), typeof(Contract.status), typeof(Contract.expireDate), typeof(ContractBillingSchedule.lastDate), typeof(ContractBillingSchedule.nextDate)); select.DescriptionField = typeof(Contract.description); _Attributes.Add(select); _SelAttrIndex = _Attributes.Count - 1; }
public SOCreateProjectionAttribute() : base(typeof(SOCreateFilter), BqlCommand.Compose( typeof(Select2 <, ,>), typeof(INItemPlan), typeof(InnerJoin <INPlanType, On <INPlanType.planType, Equal <INItemPlan.planType> >, InnerJoin <InventoryItem, On <InventoryItem.inventoryID, Equal <INItemPlan.inventoryID> >, InnerJoin <INUnit, On <INUnit.inventoryID, Equal <InventoryItem.inventoryID>, And <INUnit.fromUnit, Equal <InventoryItem.purchaseUnit>, And <INUnit.toUnit, Equal <InventoryItem.baseUnit> > > >, LeftJoin <IN.S.INItemSite, On <IN.S.INItemSite.inventoryID, Equal <INItemPlan.inventoryID>, And <IN.S.INItemSite.siteID, Equal <INItemPlan.siteID> > > > > > >), typeof(Where2 <,>), typeof(Where <INItemPlan.hold, Equal <boolFalse>, And <INItemPlan.fixedSource, Equal <INReplenishmentSource.transfer>, And <Where <INItemPlan.supplyPlanID, IsNull, Or <INItemPlan.planType, Equal <INPlanConstants.plan6B>, Or <INItemPlan.planType, Equal <INPlanConstants.plan6E> > > > > > >), typeof(And <>), TM.OwnedFilter.ProjectionAttribute.ComposeWhere( typeof(SOCreateFilter), typeof(InventoryItem.productWorkgroupID), typeof(InventoryItem.productManagerID)))) { }
protected virtual void BatchSelection_RowInserted(PXCache sender, PXRowInsertedEventArgs e) { BatchSelection batch = e.Row as BatchSelection; if (batch != null && !string.IsNullOrWhiteSpace(batch.Module) && !string.IsNullOrWhiteSpace(batch.BatchNbr)) { batch = PXSelectReadonly < BatchSelection, Where < BatchSelection.module, Equal <Required <BatchSelection.module> >, And <BatchSelection.batchNbr, Equal <Required <BatchSelection.batchNbr> > > > > .Select(this, batch.Module, batch.BatchNbr); PXSelectorAttribute selectorAttr = (PXSelectorAttribute)sender.GetAttributesReadonly <BatchSelection.batchNbr>(batch).FirstOrDefault( (PXEventSubscriberAttribute attr) => { return(attr is PXSelectorAttribute); }); BqlCommand selectorSearch = selectorAttr.GetSelect(); if (batch != null && selectorSearch.Meet(sender, batch)) { Batch_Detail.Delete(batch); Batch_Detail.Update(batch); } else { batch = (BatchSelection)e.Row; sender.RaiseExceptionHandling <BatchSelection.batchNbr>(batch, batch.BatchNbr, new PXSetPropertyException(Messages.BatchNbrNotValid)); Batch_Detail.Delete(batch); } } }
private static Type getAPDocumentSelect(bool groupBy = false) { Type selType = typeof(Select2 <, ,>); if (groupBy) { selType = typeof(Select5 <, , ,>); } Type table = typeof(APInvoice); Type join = typeof(InnerJoin <Vendor, On <Vendor.bAccountID, Equal <APInvoice.vendorID> >, InnerJoin <CurrencyInfo, On <CurrencyInfo.curyInfoID, Equal <APInvoice.curyInfoID> >, LeftJoin <APAdjust, On <APAdjust.adjdDocType, Equal <APInvoice.docType>, And <APAdjust.adjdRefNbr, Equal <APInvoice.refNbr>, And <APAdjust.released, Equal <False> > > >, LeftJoin <APPayment, On <APPayment.docType, Equal <APInvoice.docType>, And <APPayment.refNbr, Equal <APInvoice.refNbr>, And <Where <APPayment.docType, Equal <APDocType.prepayment>, Or <APPayment.docType, Equal <APDocType.debitAdj> > > > > > > > > >); Type where = typeof(Where <APInvoice.openDoc, Equal <True>, And2 <Where <APInvoice.released, Equal <True>, Or <APInvoice.prebooked, Equal <True> > >, And <APAdjust.adjgRefNbr, IsNull, And <APPayment.refNbr, IsNull, And2 <Match <Vendor, Current <AccessInfo.userName> >, And2 <Where <APInvoice.curyID, Equal <Current <ApproveBillsFilter.curyID> >, Or <Current <ApproveBillsFilter.curyID>, IsNull> >, And2 <Where2 <Where <Current <ApproveBillsFilter.showApprovedForPayment>, Equal <True>, And <APInvoice.paySel, Equal <True> > >, Or <Where <Current <ApproveBillsFilter.showNotApprovedForPayment>, Equal <True>, And <APInvoice.paySel, Equal <False> > > > >, And2 <Where <Vendor.bAccountID, Equal <Current <ApproveBillsFilter.vendorID> >, Or <Current <ApproveBillsFilter.vendorID>, IsNull> >, And2 <Where <Vendor.vendorClassID, Equal <Current <ApproveBillsFilter.vendorClassID> >, Or <Current <ApproveBillsFilter.vendorClassID>, IsNull> >, And <Where2 <Where2 <Where <Current <ApproveBillsFilter.showPayInLessThan>, Equal <True>, And <APInvoice.payDate, LessEqual <Required <APInvoice.payDate> > > >, Or2 <Where <Current <ApproveBillsFilter.showDueInLessThan>, Equal <True>, And <APInvoice.dueDate, LessEqual <Required <APInvoice.dueDate> > > >, Or <Where <Current <ApproveBillsFilter.showDiscountExpiresInLessThan>, Equal <True>, And <APInvoice.discDate, LessEqual <Required <APInvoice.discDate> > > > > > >, Or <Where <Current <ApproveBillsFilter.showPayInLessThan>, Equal <False>, And <Current <ApproveBillsFilter.showDueInLessThan>, Equal <False>, And <Current <ApproveBillsFilter.showDiscountExpiresInLessThan>, Equal <False> > > > > > > > > > > > > > > >); Type aggr = typeof(Aggregate < GroupBy <APInvoice.paySel, Sum <APInvoice.docBal, Sum <APInvoice.curyDocBal> > > >); if (groupBy) { return(BqlCommand.Compose(selType, table, join, where, aggr)); } else { return(BqlCommand.Compose(selType, table, join, where)); } }
protected virtual void MarkAs(PXCache cache, CRActivity row, Guid UserID, int status) { if (IsImport || row.NoteID == null) { return; } var noteidType = typeof(TMaster).GetNestedType(typeof(CRActivity.noteID).Name); var ownerType = typeof(TMaster).GetNestedType(typeof(CRActivity.ownerID).Name); var select = BqlCommand.Compose( typeof(Select <,>), typeof(EPView), typeof(Where <, ,>), typeof(EPView.noteID), typeof(Equal <>), typeof(Required <>), noteidType, typeof(And <,>), typeof(EPView.userID), typeof(Equal <>), typeof(Required <>), ownerType ); EPView epview = (EPView) new PXView(this, false, BqlCommand.CreateInstance(select)).SelectSingle(row.NoteID, UserID); if (epview == null) { epview = new EPView { NoteID = row.NoteID, UserID = UserID, }; } else { epview = PXCache <EPView> .CreateCopy(epview); } if (status == EPViewStatusAttribute.VIEWED ? epview.Status != EPViewStatusAttribute.VIEWED : epview.Status == EPViewStatusAttribute.VIEWED) { epview.Status = status; EPViews.Update(epview); bool isDirty = false; foreach (PXCache c in Views.Caches.Where(t => t != typeof(EPView)).Select(t => Caches[t])) { isDirty = c.Inserted.ToArray <object>().Any() || c.Updated.ToArray <object>().Any() || c.Deleted.ToArray <object>().Any(); if (isDirty) { break; } } if (!isDirty) { using (PXTransactionScope ts = new PXTransactionScope()) { Persist(); ts.Complete(); } } EPViews.Cache.IsDirty = false; } }
public virtual bool AppendExpression(ref SQLExpression exp, PXGraph graph, BqlCommandInfo info, BqlCommand.Selection selection) { bool status = true; if (info.Fields is BqlCommand.EqualityList list) { list.NonStrict = true; } SQLExpression opUser = null; if (!typeof(IBqlCreator).IsAssignableFrom(typeof(OperandUser))) { if (info.BuildExpression) { opUser = BqlCommand.GetSingleExpression(typeof(OperandUser), graph, info.Tables, selection, BqlCommand.FieldPlace.Condition); } info.Fields?.Add(typeof(OperandUser)); } else { if (_operandUser == null) { _operandUser = _operandUser.createOperand <OperandUser>(); } status &= _operandUser.AppendExpression(ref opUser, graph, info, selection); } Query qin = new Query(); qin[typeof(EPCompanyTreeH.workGroupID)].From(typeof(EPCompanyTreeH)) .Join(typeof(EPCompanyTreeMember)) .On(SQLExpression.EQ(typeof(EPCompanyTreeH.parentWGID), typeof(EPCompanyTreeMember.workGroupID)) //.And(Column.SQLColumn(typeof(EPCompanyTreeH.parentWGID)).NotEqual(Column.SQLColumn(typeof(EPCompanyTreeH.workGroupID))) .And(Column.SQLColumn(typeof(EPCompanyTreeMember.active)).EQ(1)) .And(Column.SQLColumn(typeof(EPCompanyTreeMember.userID)).EQ(opUser))) //) .Where(new SQLConst(1).EQ(1)); Query qout = new Query(); //Append Tail removes main object, so we fieldNote will not be mapped. Skipping conditions for AppendTail if (info.Tables == null || info.Tables.Count <= 0 || info.Tables.Contains(BqlCommand.GetItemType <FieldNote>())) { qout[typeof(EntityWorkgroup.refNoteID)].From(typeof(EntityWorkgroup)) .Where(Column.SQLColumn(typeof(EntityWorkgroup.workGroupID)).In(qin) .And(SQLExpression.EQ(typeof(EntityWorkgroup.refNoteID), typeof(FieldNote)))); } else { qout[typeof(EntityWorkgroup.refNoteID)].From(typeof(EntityWorkgroup)) .Where(Column.SQLColumn(typeof(EntityWorkgroup.workGroupID)).In(qin)); } qout.Limit(-1); // prevent limiting of IN subqueries exp = exp.In(qout); return(status); }
public static BqlCommand CreateSelectCommand(Type entityType, Type fieldType) { Type required = BqlCommand.Compose(typeof(Required <>), fieldType); Type equal = BqlCommand.Compose(typeof(Equal <>), required); Type where = BqlCommand.Compose(typeof(Where <,>), fieldType, equal); return(BqlCommand.CreateInstance(typeof(Select <,>), entityType, where)); }
private static int?GetAssignmentMapId(PXGraph graph) { BqlCommand search = (BqlCommand)Activator.CreateInstance(BqlCommand.Compose(typeof(Search <>), typeof(TAssignmentMapField))); PXView view = new PXView(graph, true, BqlCommand.CreateInstance(search.GetSelectType())); object row = view.SelectSingle(); return(row.With(_ => (int?)view.Cache.GetValue(_, ((IBqlSearch)search).GetField().Name))); }
internal DummyView(PXGraph graph, BqlCommand command, List<object> records) : base(graph, true, command) { _Records = records; }
public override void CacheAttached(PXCache sender) { base.CacheAttached(sender); _select = BqlCommand.CreateInstance(typeof(Select2<FABook, InnerJoin<FABookSettings, On<FABookSettings.bookID, Equal<FABook.bookID>>>, Where<FABookSettings.assetID, Equal<Current<FABookBalance.classID>>>>)); }