XRM Metadata SDK in TypeScript
| export interface XrmMetaAttribute { | |
| LogicalName: string; | |
| MetadataId: string; | |
| DisplayName: DisplayName; | |
| Description: Description; | |
| IsCustomizable: IsCustomizable; | |
| IsAuditEnabled: IsAuditEnabled; | |
| OptionsSet: any; | |
| AttributeType: string; | |
| HasChanged?: any; | |
| AttributeOf?: any; | |
| ColumnNumber: number; | |
| DeprecatedVersion?: any; | |
| IntroducedVersion: string; | |
| EntityLogicalName: string; | |
| IsCustomAttribute: boolean; | |
| IsPrimaryId: boolean; | |
| IsPrimaryName: boolean; | |
| IsValidForCreate: boolean; | |
| IsValidForRead: boolean; | |
| IsValidForUpdate: boolean; | |
| CanBeSecuredForRead: boolean; | |
| CanBeSecuredForCreate: boolean; | |
| CanBeSecuredForUpdate: boolean; | |
| IsSecured: boolean; | |
| IsRetrievable: boolean; | |
| IsFilterable: boolean; | |
| IsSearchable: boolean; | |
| IsManaged: boolean; | |
| LinkedAttributeId?: any; | |
| IsValidForForm: boolean; | |
| IsRequiredForForm: boolean; | |
| IsValidForGrid: boolean; | |
| SchemaName: string; | |
| ExternalName?: any; | |
| IsLogical: boolean; | |
| IsDataSourceSecret: boolean; | |
| InheritsFrom?: any; | |
| SourceType: number; | |
| AutoNumberFormat: string; | |
| Format: string; | |
| ImeMode: string; | |
| MaxLength: number; | |
| YomiOf?: any; | |
| IsLocalizable: boolean; | |
| DatabaseLength: number; | |
| FormulaDefinition?: any; | |
| SourceTypeMask: number; | |
| AttributeTypeName: AttributeTypeName; | |
| IsValidForAdvancedFind: IsValidForAdvancedFind; | |
| RequiredLevel: RequiredLevel; | |
| FormatName: FormatName; | |
| Targets: string[]; | |
| } | |
| export interface XrmMetaEntity { | |
| LogicalName: string; | |
| MetadataId: string; | |
| DisplayName: DisplayName; | |
| Description: Description; | |
| IsCustomizable: IsCustomizable; | |
| IsAuditEnabled: IsAuditEnabled; | |
| HasChanged: any; | |
| ActivityTypeMask: number; | |
| Attributes: XrmMetaAttribute[]; | |
| DisplayCollectionName: DisplayCollectionName; | |
| IsActivity: boolean; | |
| IsActivityParty: boolean; | |
| IsBusinessProcessEnabled: string; | |
| IsChildEntity: boolean; | |
| IsCustomEntity: boolean; | |
| IsValidForAdvancedFind: boolean; | |
| IsValidForQueue: IsValidForQueue; | |
| ManyToManyRelationships: XrmMetaManyToManyRelation[]; | |
| ManyToOneRelationships: XrmMetaOneToManyRelation[]; | |
| ObjectTypeCode: number; | |
| OneToManyRelationships: XrmMetaOneToManyRelation[]; | |
| OwnershipType: string; | |
| PrimaryIdAttribute: string; | |
| PrimaryNameAttribute: string; | |
| SchemaName: string; | |
| CollectionSchemaName: string; | |
| Keys: any; | |
| EntitySetName: string; | |
| _type: string; | |
| } | |
| export enum XrmEntityFilter { | |
| Default = 1, | |
| Entity = 1, | |
| Attributes = 2, | |
| Privileges = 4, | |
| Relationships = 8, | |
| All = 15 | |
| } | |
| export interface AttributeTypeName { | |
| Value: string; | |
| } | |
| export interface FormatName { | |
| Value: string; | |
| } | |
| export interface RequiredLevel { | |
| Value: string; | |
| CanBeChanged: boolean; | |
| ManagedPropertyLogicalName: string; | |
| } | |
| export interface IsValidForAdvancedFind { | |
| Value: boolean; | |
| CanBeChanged: boolean; | |
| ManagedPropertyLogicalName: string; | |
| } | |
| export interface LocalizedLabel { | |
| MetadataId: string; | |
| HasChanged?: any; | |
| IsManaged: boolean; | |
| Label: any; | |
| LanguageCode: number; | |
| _type: string; | |
| } | |
| export interface UserLocalizedLabel { | |
| MetadataId: string; | |
| HasChanged?: any; | |
| IsManaged: boolean; | |
| Label?: any; | |
| LanguageCode: number; | |
| } | |
| export interface Description { | |
| LocalizedLabels: LocalizedLabel[]; | |
| UserLocalizedLabel: UserLocalizedLabel; | |
| } | |
| export interface LocalizedLabel { | |
| Label: any; | |
| MetadataId: string; | |
| HasChanged?: any; | |
| IsManaged: boolean; | |
| LanguageCode: number; | |
| _type: string; | |
| } | |
| export interface DisplayCollectionName { | |
| LocalizedLabels: LocalizedLabel[]; | |
| UserLocalizedLabel: UserLocalizedLabel; | |
| } | |
| export interface LocalizedLabel { | |
| MetadataId: string; | |
| HasChanged?: any; | |
| IsManaged: boolean; | |
| Label: any; | |
| LanguageCode: number; | |
| _type: string; | |
| } | |
| export interface DisplayName { | |
| LocalizedLabels: LocalizedLabel[]; | |
| UserLocalizedLabel: UserLocalizedLabel; | |
| } | |
| export interface IsAuditEnabled { | |
| CanBeChanged: boolean; | |
| ManagedPropertyLogicalName: string; | |
| Value: boolean; | |
| } | |
| export interface IsCustomizable { | |
| CanBeChanged: boolean; | |
| ManagedPropertyLogicalName: string; | |
| Value: boolean; | |
| } | |
| export interface IsValidForQueue { | |
| CanBeChanged: boolean; | |
| ManagedPropertyLogicalName: string; | |
| Value: boolean; | |
| } | |
| export interface XrmMetaRelation { | |
| IsCustomRelationship?: boolean; | |
| IsValidForAdvancedFind?: boolean; | |
| SchemaName: string; | |
| RelationshipType?: XrmMetaRelationshipType; | |
| } | |
| export interface XrmMetaOneToManyRelation extends XrmMetaRelation { | |
| ReferencedAttribute: string; | |
| ReferencedEntity: string; | |
| ReferencingAttribute: string; | |
| ReferencingEntity: string; | |
| ReferencedEntityNavigationPropertyName: string; | |
| ReferencingEntityNavigationPropertyName: string; | |
| } | |
| export interface XrmMetaManyToManyRelation extends XrmMetaRelation { | |
| Entity1LogicalName: string; | |
| Entity2LogicalName: string; | |
| IntersectEntityName: string; | |
| Entity1IntersectAttribute: string; | |
| Entity2IntersectAttribute: string; | |
| Entity1NavigationPropertyName: string; | |
| Entity2NavigationPropertyName: string; | |
| } | |
| export enum XrmMetaRelationshipType { | |
| OneToManyRelationship = 0, | |
| Default = 0, | |
| ManyToManyRelationship = 1 | |
| } |
| import { Observable } from "rxjs"; | |
| import { HttpClient, HttpHeaders } from "@angular/common/http"; | |
| // tslint:disable:no-bitwise | |
| // tslint:disable:max-line-length | |
| export class XrmMetaSdk { | |
| private _arrayElements = [ | |
| "Attributes", | |
| "ManyToManyRelationships", | |
| "ManyToOneRelationships", | |
| "OneToManyRelationships", | |
| "Privileges", | |
| "LocalizedLabels", | |
| "Options", | |
| "Targets" | |
| ]; | |
| constructor(private http: HttpClient, private clientUrl: string) {} | |
| public GetTables(): Observable<IQueryTable[]> { | |
| const _this = this; | |
| return new Observable<IQueryTable[]>(subscriber => { | |
| if (_this.IsLocal()) { | |
| this.http | |
| .get<XrmMetaEntity[]>("http://localhost:54566/GetEntity") | |
| .subscribe( | |
| entities => { | |
| subscriber.next(this.ParseTables(entities)); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| }, | |
| () => { | |
| subscriber.complete(); | |
| } | |
| ); | |
| } else { | |
| _this.RetrieveAllEntities( | |
| (entities: XrmMetaEntity[]) => { | |
| subscriber.next(this.ParseTables(entities)); | |
| subscriber.complete(); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| } | |
| ); | |
| } | |
| }); | |
| } | |
| public GetColumnsOfTable(table: IQueryTable): Observable<IQueryColumn[]> { | |
| const _this = this; | |
| return new Observable<IQueryColumn[]>(subscriber => { | |
| if (_this.IsLocal()) { | |
| this.http | |
| .get<XrmMetaAttribute[]>( | |
| "http://localhost:54566/GetAttribute/" + table.Id | |
| ) | |
| .subscribe( | |
| attributes => { | |
| const columns = _this.ParseColumns(table.Id, attributes); | |
| subscriber.next(columns); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| }, | |
| () => { | |
| subscriber.complete(); | |
| } | |
| ); | |
| } else { | |
| const __this = _this; | |
| _this.RetrieveAttributes( | |
| table.Id, | |
| (attributes: XrmMetaAttribute[]) => { | |
| const columns = _this.ParseColumns(table.Id, attributes); | |
| subscriber.next(columns); | |
| subscriber.complete(); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| } | |
| ); | |
| } | |
| }); | |
| } | |
| public GetRelationsOfTable(table: IQueryTable): Observable<IQueryRelation[]> { | |
| const _this = this; | |
| return new Observable<IQueryRelation[]>(subscriber => { | |
| if (_this.IsLocal()) { | |
| _this.http | |
| .get<XrmMetaEntity>( | |
| "http://localhost:54566/GetRelationships/" + table.Id | |
| ) | |
| .subscribe( | |
| entity => { | |
| const o2ms = entity.OneToManyRelationships; | |
| const m2os = entity.ManyToOneRelationships; | |
| const m2ms = entity.ManyToManyRelationships; | |
| subscriber.next(this.ParseRelations(table.Id, o2ms, m2os, m2ms)); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| }, | |
| () => { | |
| subscriber.complete(); | |
| } | |
| ); | |
| } else { | |
| const __this = _this; | |
| __this.RetrieveRelations( | |
| table.Id, | |
| entity => { | |
| const o2ms = entity.OneToManyRelationships; | |
| const m2os = entity.ManyToOneRelationships; | |
| const m2ms = entity.ManyToManyRelationships; | |
| subscriber.next(this.ParseRelations(table.Id, o2ms, m2os, m2ms)); | |
| subscriber.complete(); | |
| }, | |
| err => { | |
| subscriber.error(err); | |
| } | |
| ); | |
| } | |
| }); | |
| } | |
| private ParseTables(entities: XrmMetaEntity[]): IQueryTable[] { | |
| const tables = entities.map(entity => { | |
| return { | |
| Alias: "", | |
| Id: entity.LogicalName, | |
| Name: this.readLabel(entity), | |
| PrimaryKeyName: entity.PrimaryIdAttribute, | |
| PrimaryName: entity.PrimaryNameAttribute | |
| } as IQueryTable; | |
| }); | |
| return tables; | |
| } | |
| private ParseColumns( | |
| tableId: string, | |
| attributes: XrmMetaAttribute[] | |
| ): IQueryColumn[] { | |
| const columns = attributes.map(att => { | |
| return { | |
| Alias: "", | |
| Id: att.LogicalName, | |
| Name: this.readLabel(att), | |
| Table: tableId, | |
| OptionSet: this.readOption(att), | |
| Type: this.readAttributeType(att.AttributeType), | |
| Targets: att.Targets | |
| } as IQueryColumn; | |
| }); | |
| return columns; | |
| } | |
| private ParseRelations( | |
| tableId: string, | |
| o2ms: XrmMetaOneToManyRelation[], | |
| m2os: XrmMetaOneToManyRelation[], | |
| m2ms: XrmMetaManyToManyRelation[] | |
| ): IQueryRelation[] { | |
| const relations: IQueryRelation[] = []; | |
| for (let i = 0; i < o2ms.length; i++) { | |
| const o2m = o2ms[i]; | |
| const relation: IQueryRelation = ({ | |
| ParentColumn: o2m.ReferencedAttribute, | |
| ParentTable: o2m.ReferencedEntity, | |
| ChildColumn: o2m.ReferencingAttribute, | |
| ChildTable: o2m.ReferencingEntity, | |
| Id: o2m.SchemaName, | |
| RelationType: QueryRelationType.OneToMany | |
| } as any) as IQueryRelation; | |
| relations.push(relation); | |
| } | |
| for (let i = 0; i < m2os.length; i++) { | |
| const m2o = m2os[i]; | |
| const relation: IQueryRelation = ({ | |
| ChildColumn: m2o.ReferencedAttribute, | |
| ChildTable: m2o.ReferencedEntity, | |
| ParentColumn: m2o.ReferencingAttribute, | |
| ParentTable: m2o.ReferencingEntity, | |
| Id: m2o.SchemaName, | |
| RelationType: QueryRelationType.ManyToOne | |
| } as any) as IQueryRelation; | |
| relations.push(relation); | |
| } | |
| for (let i = 0; i < m2ms.length; i++) { | |
| const m2m = m2ms[i]; | |
| let pC, cC, pT, cT, iP, iC; | |
| if (m2m.Entity1LogicalName.toLowerCase() === tableId.toLowerCase()) { | |
| pT = m2m.Entity1LogicalName; | |
| cT = m2m.Entity2LogicalName; | |
| iP = m2m.Entity1IntersectAttribute; | |
| iC = m2m.Entity2IntersectAttribute; | |
| } else { | |
| pT = m2m.Entity2LogicalName; | |
| cT = m2m.Entity1LogicalName; | |
| iP = m2m.Entity2IntersectAttribute; | |
| iC = m2m.Entity1IntersectAttribute; | |
| } | |
| // TODO: Add proper table id here | |
| pC = pT + "id"; | |
| cC = cT + "id"; | |
| const relation: IQueryRelation = { | |
| ChildColumn: cC, | |
| ChildTable: cT, | |
| ParentColumn: pC, | |
| ParentTable: pT, | |
| Id: m2m.SchemaName, | |
| RelationType: QueryRelationType.ManyToMany, | |
| IntermediateChildColumn: iC, | |
| IntermediateParentColumn: iP, | |
| IntermediateTable: m2m.IntersectEntityName | |
| } as IQueryRelation; | |
| relations.push(relation); | |
| } | |
| return relations; | |
| } | |
| public GetOperatorsOfColumn(column: IQueryColumn): OperatorMap { | |
| const operators: OperatorMap = new OperatorMap(); | |
| switch (column.Type) { | |
| case QueryColumnType.Boolean: { | |
| operators.push( | |
| QueryOperatorType.Equal, | |
| QueryOperandInputType.TwoOptions | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.TwoOptions | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.Customer: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Customer); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Customer | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.CustomerMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.CustomerMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.DateTime: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.DateTime); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.InFiscalPeriod, | |
| QueryOperandInputType.DateTimePe | |
| ); | |
| operators.push( | |
| QueryOperatorType.InFiscalPeriodAndYear, | |
| QueryOperandInputType.DateTimeFyPe | |
| ); | |
| operators.push( | |
| QueryOperatorType.InFiscalYear, | |
| QueryOperandInputType.DateTimeFy | |
| ); | |
| operators.push( | |
| QueryOperatorType.InOrAfterFiscalPeriodAndYear, | |
| QueryOperandInputType.DateTimeFyPe | |
| ); | |
| operators.push( | |
| QueryOperatorType.InOrBeforeFiscalPeriodAndYear, | |
| QueryOperandInputType.DateTimeFyPe | |
| ); | |
| operators.push(QueryOperatorType.Last7Days, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.LastFiscalPeriod, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastFiscalYear, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push(QueryOperatorType.LastMonth, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.LastWeek, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.LastXDays, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXFiscalPeriods, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXFiscalYears, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXHours, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXMonths, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXWeeks, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastXYears, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LastYear, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push(QueryOperatorType.Next7Days, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.NextFiscalPeriod, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextFiscalYear, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push(QueryOperatorType.NextMonth, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NextWeek, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.NextXDays, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXFiscalPeriods, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXFiscalYears, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXHours, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXMonths, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXWeeks, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.NextXYears, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push(QueryOperatorType.NextYear, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.OlderThanXYears, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.OlderThanXMonths, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.OlderThanXWeeks, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.OlderThanXDays, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.OlderThanXHours, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.OlderThanXMinutes, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push(QueryOperatorType.On, QueryOperandInputType.DateTime); | |
| operators.push( | |
| QueryOperatorType.OnOrAfter, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push( | |
| QueryOperatorType.OnOrBefore, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push( | |
| QueryOperatorType.ThisFiscalPeriod, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push( | |
| QueryOperatorType.ThisFiscalYear, | |
| QueryOperandInputType.None | |
| ); | |
| operators.push(QueryOperatorType.ThisMonth, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.ThisWeek, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.ThisYear, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.Today, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.Tomorrow, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.Yesterday, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotOn, QueryOperandInputType.DateTime); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.DateTime | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.DateTime | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Decimal: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Decimal); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.DecimalMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.DecimalMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.DecimalRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.DecimalRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Decimal | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Double: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Double); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Double | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.DoubleMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.DoubleMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.DoubleRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.DoubleRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Double | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Double | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Double | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Double | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Integer: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Integer); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.IntegerMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.IntegerMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Lookup: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Lookup); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.LookupMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.LookupMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.Memo: { | |
| operators.push( | |
| QueryOperatorType.Equal, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.StringMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.StringMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.Paragraph); | |
| operators.push( | |
| QueryOperatorType.NotLike, | |
| QueryOperandInputType.Paragraph | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Money: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Decimal); | |
| operators.push(QueryOperatorType.NotEqual, QueryOperandInputType.Decimal); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.DecimalMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.DecimalMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.DecimalRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.DecimalRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Decimal | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Decimal | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Owner: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Owner); | |
| operators.push(QueryOperatorType.NotEqual, QueryOperandInputType.Owner); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.OwnerMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.OwnerMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.EqualUserId, | |
| QueryOperandInputType.User | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotEqualUserId, | |
| QueryOperandInputType.User | |
| ); | |
| operators.push( | |
| QueryOperatorType.EqualUserOrUserHierarchy, | |
| QueryOperandInputType.User | |
| ); | |
| operators.push( | |
| QueryOperatorType.EqualUserOrUserHierarchyAndTeams, | |
| QueryOperandInputType.UserTeamMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.EqualUserOrUserTeams, | |
| QueryOperandInputType.UserTeamMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.PartyList: { | |
| operators.push( | |
| QueryOperatorType.Equal, | |
| QueryOperandInputType.PartyList | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.PartyList | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.PartyListMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.PartyListMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| break; | |
| } | |
| case QueryColumnType.Picklist: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Options); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Options | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.State: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Options); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Options | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.Status: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Options); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Options | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.OptionsMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.IntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.Integer | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.Integer | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.String: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.StringMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.StringMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.Uniqueidentifier: { | |
| operators.push(QueryOperatorType.Equal, QueryOperandInputType.Lookup); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.LookupMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.LookupMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.Above, QueryOperandInputType.Lookup); | |
| operators.push( | |
| QueryOperatorType.AboveOrEqual, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push(QueryOperatorType.Under, QueryOperandInputType.Lookup); | |
| operators.push( | |
| QueryOperatorType.UnderOrEqual, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotUnder, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.EqualBusinessId, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.EqualUserId, | |
| QueryOperandInputType.Lookup | |
| ); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| break; | |
| } | |
| case QueryColumnType.CalendarRules: { | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| break; | |
| } | |
| case QueryColumnType.Virtual: { | |
| break; | |
| } | |
| case QueryColumnType.BigInt: { | |
| operators.push( | |
| QueryOperatorType.Equal, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotEqual, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| operators.push( | |
| QueryOperatorType.In, | |
| QueryOperandInputType.BigIntegerMultiple | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotIn, | |
| QueryOperandInputType.BigIntegerMultiple | |
| ); | |
| operators.push(QueryOperatorType.Null, QueryOperandInputType.None); | |
| operators.push(QueryOperatorType.NotNull, QueryOperandInputType.None); | |
| operators.push( | |
| QueryOperatorType.BeginsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotBeginWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.Contains, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotContain, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.EndsWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push( | |
| QueryOperatorType.DoesNotEndWith, | |
| QueryOperandInputType.String | |
| ); | |
| operators.push(QueryOperatorType.Like, QueryOperandInputType.String); | |
| operators.push(QueryOperatorType.NotLike, QueryOperandInputType.String); | |
| operators.push( | |
| QueryOperatorType.Between, | |
| QueryOperandInputType.BigIntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.NotBetween, | |
| QueryOperandInputType.BigIntegerRange | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterThan, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| operators.push( | |
| QueryOperatorType.GreaterEqual, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessThan, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| operators.push( | |
| QueryOperatorType.LessEqual, | |
| QueryOperandInputType.BigInteger | |
| ); | |
| break; | |
| } | |
| case QueryColumnType.ManagedProperty: { | |
| break; | |
| } | |
| case QueryColumnType.EntityName: { | |
| break; | |
| } | |
| } | |
| return operators; | |
| } | |
| public GetInputParentType(inputType: QueryOperandInputType): QueryOperandType { | |
| switch (inputType) { | |
| case QueryOperandInputType.Integer: | |
| case QueryOperandInputType.IntegerMultiple: | |
| case QueryOperandInputType.IntegerRange: | |
| case QueryOperandInputType.BigInteger: | |
| case QueryOperandInputType.BigIntegerMultiple: | |
| case QueryOperandInputType.BigIntegerRange: | |
| case QueryOperandInputType.Decimal: | |
| case QueryOperandInputType.DecimalMultiple: | |
| case QueryOperandInputType.DecimalRange: | |
| case QueryOperandInputType.Double: | |
| case QueryOperandInputType.DoubleMultiple: | |
| case QueryOperandInputType.DoubleRange: | |
| return QueryOperandType.Number; | |
| case QueryOperandInputType.String: | |
| case QueryOperandInputType.StringMultiple: | |
| case QueryOperandInputType.Paragraph: | |
| return QueryOperandType.String; | |
| case QueryOperandInputType.DateTime: | |
| case QueryOperandInputType.DateTimeFy: | |
| case QueryOperandInputType.DateTimePe: | |
| case QueryOperandInputType.DateTimeFyPe: | |
| return QueryOperandType.DateTime; | |
| case QueryOperandInputType.Lookup: | |
| case QueryOperandInputType.LookupMultiple: | |
| case QueryOperandInputType.Customer: | |
| case QueryOperandInputType.CustomerMultiple: | |
| case QueryOperandInputType.Owner: | |
| case QueryOperandInputType.OwnerMultiple: | |
| case QueryOperandInputType.PartyList: | |
| case QueryOperandInputType.PartyListMultiple: | |
| case QueryOperandInputType.User: | |
| case QueryOperandInputType.UserTeam: | |
| case QueryOperandInputType.UserTeamMultiple: | |
| return QueryOperandType.Lookup; | |
| case QueryOperandInputType.TwoOptions: { | |
| return QueryOperandType.TwoOptions; | |
| } | |
| case QueryOperandInputType.Options: | |
| case QueryOperandInputType.OptionsMultiple: | |
| return QueryOperandType.Options; | |
| default: { | |
| return QueryOperandType.None; | |
| } | |
| } | |
| } | |
| //#region helpers | |
| private readLabel(metaRecord: any): string { | |
| try { | |
| const disp = metaRecord.DisplayName as DisplayName; | |
| return disp.UserLocalizedLabel.Label; | |
| } catch { | |
| let label = null; | |
| for (let i = 0; i < metaRecord.DisplayName.LocalizedLabels.length; i++) { | |
| if (metaRecord.DisplayName.LocalizedLabels[i].LanguageCode === 1033) { | |
| label = metaRecord.DisplayName.LocalizedLabels[i].Label; | |
| } | |
| } | |
| if (label === null) { | |
| if (metaRecord.DisplayName.LocalizedLabels.length > 0) { | |
| label = metaRecord.DisplayName.LocalizedLabels[0].Label; | |
| } else { | |
| label = metaRecord.LogicalName; | |
| } | |
| } | |
| return label; | |
| } | |
| } | |
| private readOption(att: XrmMetaAttribute): IQueryOption[] { | |
| try { | |
| return att.OptionSet.Options.map(op => { | |
| return { | |
| Key: this.readOptionLabel(op), | |
| Value: op.Value | |
| } as IQueryOption; | |
| }); | |
| } catch { | |
| return []; | |
| } | |
| } | |
| private readOptionLabel(metaRecord: any): string { | |
| try { | |
| const disp = metaRecord.DisplayName as DisplayName; | |
| return disp.UserLocalizedLabel.Label; | |
| } catch { | |
| let label = null; | |
| for (let i = 0; i < metaRecord.Label.LocalizedLabels.length; i++) { | |
| if (metaRecord.Label.LocalizedLabels[i].LanguageCode === 1033) { | |
| label = metaRecord.Label.LocalizedLabels[i].Label; | |
| } | |
| } | |
| if (label === null) { | |
| if (metaRecord.Label.LocalizedLabels.length > 0) { | |
| label = metaRecord.Label.LocalizedLabels[0].Label; | |
| } else { | |
| label = "Option #"; | |
| } | |
| } | |
| return label; | |
| } | |
| } | |
| private readAttributeType(type: string): QueryColumnType { | |
| switch (type) { | |
| case "Lookup": { | |
| return QueryColumnType.Lookup; | |
| } | |
| case "State": { | |
| return QueryColumnType.State; | |
| } | |
| case "Memo": { | |
| return QueryColumnType.Memo; | |
| } | |
| case "Boolean": { | |
| return QueryColumnType.Boolean; | |
| } | |
| case "String": { | |
| return QueryColumnType.String; | |
| } | |
| case "Integer": { | |
| return QueryColumnType.Integer; | |
| } | |
| case "DateTime": { | |
| return QueryColumnType.DateTime; | |
| } | |
| case "Status": { | |
| return QueryColumnType.Status; | |
| } | |
| case "Uniqueidentifier": { | |
| return QueryColumnType.Uniqueidentifier; | |
| } | |
| case "Picklist": { | |
| return QueryColumnType.Picklist; | |
| } | |
| case "Owner": { | |
| return QueryColumnType.Owner; | |
| } | |
| case "BigInt": { | |
| return QueryColumnType.BigInt; | |
| } | |
| case "EntityName": { | |
| return QueryColumnType.EntityName; | |
| } | |
| case "Virtual": { | |
| return QueryColumnType.Virtual; | |
| } | |
| case "Decimal": { | |
| return QueryColumnType.Decimal; | |
| } | |
| case "ManagedProperty": { | |
| return QueryColumnType.ManagedProperty; | |
| } | |
| case "Customer": { | |
| return QueryColumnType.Customer; | |
| } | |
| case "PartyList": { | |
| return QueryColumnType.PartyList; | |
| } | |
| case "Double": { | |
| return QueryColumnType.Double; | |
| } | |
| case "Money": { | |
| return QueryColumnType.Money; | |
| } | |
| case "CalendarRules": { | |
| return QueryColumnType.CalendarRules; | |
| } | |
| default: { | |
| return QueryColumnType.None; | |
| } | |
| } | |
| } | |
| private IsLocal(): boolean { | |
| return ( | |
| window.location.hostname === "localhost" || | |
| window.location.hostname === "127.0.01" | |
| ); | |
| } | |
| private getUrl() { | |
| return this.clientUrl || window.location.hostname; | |
| } | |
| //#endregion | |
| //#region internals | |
| private RetrieveAllEntities( | |
| successCallBack, | |
| errorCallBack | |
| ) { | |
| const _this = this; | |
| if (typeof successCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveAllEntities successCallBack must be a function." | |
| ); | |
| } | |
| if (typeof errorCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveAllEntities errorCallBack must be a function." | |
| ); | |
| } | |
| const entityFiltersValue = this._evaluateEntityFilters(1); | |
| const request = [ | |
| '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">', | |
| // Allows retrieval if ImageAttributeMetadata objects | |
| '<soapenv:Header><a:SdkClientVersion xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">7.0</a:SdkClientVersion></soapenv:Header>', | |
| "<soapenv:Body>", | |
| '<Execute xmlns="http://schemas.microsoft.com/xrm/2011/Contracts/Services" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">', | |
| '<request i:type="a:RetrieveAllEntitiesRequest" xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">', | |
| '<a:Parameters xmlns:b="http://schemas.datacontract.org/2004/07/System.Collections.Generic">', | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>EntityFilters</b:key>", | |
| '<b:value i:type="c:EntityFilters" xmlns:c="http://schemas.microsoft.com/xrm/2011/Metadata">' + | |
| _this._xmlEncode(entityFiltersValue) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>RetrieveAsIfPublished</b:key>", | |
| '<b:value i:type="c:boolean" xmlns:c="http://www.w3.org/2001/XMLSchema">' + | |
| _this._xmlEncode(true.toString()) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "</a:Parameters>", | |
| '<a:RequestId i:nil="true" />', | |
| "<a:RequestName>RetrieveAllEntities</a:RequestName>", | |
| "</request>", | |
| "</Execute>", | |
| "</soapenv:Body>", | |
| "</soapenv:Envelope>" | |
| ].join(""); | |
| const req = new XMLHttpRequest(); | |
| req.open( | |
| "POST", | |
| _this.getUrl() + "/XRMServices/2011/Organization.svc/web", | |
| true | |
| ); | |
| try { | |
| req.responseType = "msxml-document" as any; | |
| } catch (e) {} | |
| req.setRequestHeader("Accept", "application/xml, text/xml, */*"); | |
| req.setRequestHeader("Content-Type", "text/xml; charset=utf-8"); | |
| req.setRequestHeader( | |
| "SOAPAction", | |
| "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute" | |
| ); | |
| req.onreadystatechange = function() { | |
| const __this = _this; | |
| if (req.readyState === 4 /* complete */) { | |
| req.onreadystatechange = null; // Addresses potential memory leak issue with IE | |
| if (req.status === 200) { | |
| // Success | |
| const doc = req.responseXML; | |
| try { | |
| __this._setSelectionNamespaces(doc); | |
| } catch (e) {} | |
| const entityMetadataNodes = __this._selectNodes(doc, "//c:EntityMetadata"); | |
| const entityMetadataCollection: XrmMetaEntity[] = []; | |
| for (let i = 0; i < entityMetadataNodes.length; i++) { | |
| const a = __this._objectifyNode(entityMetadataNodes[i]); | |
| a._type = "EntityMetadata"; | |
| entityMetadataCollection.push(a); | |
| } | |
| successCallBack(entityMetadataCollection); | |
| } else { | |
| errorCallBack(__this._getError(req)); | |
| } | |
| } | |
| }; | |
| req.send(request); | |
| } | |
| private RetrieveAttributes( | |
| LogicalName, | |
| successCallBack, | |
| errorCallBack | |
| ) { | |
| let MetadataId = null; | |
| const _this = this; | |
| if (LogicalName == null && MetadataId == null) { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity requires either the LogicalName or MetadataId parameter not be null." | |
| ); | |
| } | |
| if (LogicalName != null) { | |
| if (typeof LogicalName !== "string") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity LogicalName must be a string value." | |
| ); | |
| } | |
| MetadataId = "00000000-0000-0000-0000-000000000000"; | |
| } | |
| if (MetadataId != null && LogicalName == null) { | |
| if (typeof MetadataId !== "string") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity MetadataId must be a string value." | |
| ); | |
| } | |
| } | |
| if (typeof successCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity successCallBack must be a function." | |
| ); | |
| } | |
| if (typeof errorCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity errorCallBack must be a function." | |
| ); | |
| } | |
| const entityFiltersValue = _this._evaluateEntityFilters(2); | |
| let entityLogicalNameValueNode = ""; | |
| if (LogicalName == null) { | |
| entityLogicalNameValueNode = '<b:value i:nil="true" />'; | |
| } else { | |
| entityLogicalNameValueNode = | |
| '<b:value i:type="c:string" xmlns:c="http://www.w3.org/2001/XMLSchema">' + | |
| _this._xmlEncode(LogicalName.toLowerCase()) + | |
| "</b:value>"; | |
| } | |
| const request = [ | |
| '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">', | |
| // Allows retrieval if ImageAttributeMetadata objects | |
| '<soapenv:Header><a:SdkClientVersion xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">6.0</a:SdkClientVersion></soapenv:Header>', | |
| "<soapenv:Body>", | |
| '<Execute xmlns="http://schemas.microsoft.com/xrm/2011/Contracts/Services" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">', | |
| '<request i:type="a:RetrieveEntityRequest" xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">', | |
| '<a:Parameters xmlns:b="http://schemas.datacontract.org/2004/07/System.Collections.Generic">', | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>EntityFilters</b:key>", | |
| '<b:value i:type="c:EntityFilters" xmlns:c="http://schemas.microsoft.com/xrm/2011/Metadata">' + | |
| _this._xmlEncode(entityFiltersValue) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>MetadataId</b:key>", | |
| '<b:value i:type="ser:guid" xmlns:ser="http://schemas.microsoft.com/2003/10/Serialization/">' + | |
| _this._xmlEncode(MetadataId) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>RetrieveAsIfPublished</b:key>", | |
| '<b:value i:type="c:boolean" xmlns:c="http://www.w3.org/2001/XMLSchema">' + | |
| _this._xmlEncode(true.toString()) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>LogicalName</b:key>", | |
| entityLogicalNameValueNode, | |
| "</a:KeyValuePairOfstringanyType>", | |
| "</a:Parameters>", | |
| '<a:RequestId i:nil="true" />', | |
| "<a:RequestName>RetrieveEntity</a:RequestName>", | |
| "</request>", | |
| "</Execute>", | |
| "</soapenv:Body>", | |
| "</soapenv:Envelope>" | |
| ].join(""); | |
| const req = new XMLHttpRequest(); | |
| req.open( | |
| "POST", | |
| _this.getUrl() + "/XRMServices/2011/Organization.svc/web", | |
| true | |
| ); | |
| try { | |
| req.responseType = "msxml-document" as any; | |
| } catch (e) {} | |
| req.setRequestHeader("Accept", "application/xml, text/xml, */*"); | |
| req.setRequestHeader("Content-Type", "text/xml; charset=utf-8"); | |
| req.setRequestHeader( | |
| "SOAPAction", | |
| "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute" | |
| ); | |
| req.onreadystatechange = function() { | |
| const __this = _this; | |
| if (req.readyState === 4 /* complete */) { | |
| req.onreadystatechange = null; // Addresses potential memory leak issue with IE | |
| if (req.status === 200) { | |
| const doc = req.responseXML; | |
| try { | |
| __this._setSelectionNamespaces(doc); | |
| } catch (e) {} | |
| const a: XrmMetaEntity = __this._objectifyNode(__this._selectSingleNode(doc, "//b:value")); | |
| a._type = "EntityMetadata"; | |
| successCallBack(a.Attributes); | |
| } else { | |
| // Failure | |
| errorCallBack(__this._getError(req)); | |
| } | |
| } | |
| }; | |
| req.send(request); | |
| } | |
| private RetrieveRelations( | |
| LogicalName, | |
| successCallBack, | |
| errorCallBack | |
| ) { | |
| let MetadataId = null; | |
| const _this = this; | |
| if (LogicalName == null && MetadataId == null) { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity requires either the LogicalName or MetadataId parameter not be null." | |
| ); | |
| } | |
| if (LogicalName != null) { | |
| if (typeof LogicalName !== "string") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity LogicalName must be a string value." | |
| ); | |
| } | |
| MetadataId = "00000000-0000-0000-0000-000000000000"; | |
| } | |
| if (MetadataId != null && LogicalName == null) { | |
| if (typeof MetadataId !== "string") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity MetadataId must be a string value." | |
| ); | |
| } | |
| } | |
| if (typeof successCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity successCallBack must be a function." | |
| ); | |
| } | |
| if (typeof errorCallBack !== "function") { | |
| throw new Error( | |
| "SDK.Metadata.RetrieveEntity errorCallBack must be a function." | |
| ); | |
| } | |
| const entityFiltersValue = _this._evaluateEntityFilters(8); | |
| let entityLogicalNameValueNode = ""; | |
| if (LogicalName == null) { | |
| entityLogicalNameValueNode = '<b:value i:nil="true" />'; | |
| } else { | |
| entityLogicalNameValueNode = | |
| '<b:value i:type="c:string" xmlns:c="http://www.w3.org/2001/XMLSchema">' + | |
| _this._xmlEncode(LogicalName.toLowerCase()) + | |
| "</b:value>"; | |
| } | |
| const request = [ | |
| '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">', | |
| // Allows retrieval if ImageAttributeMetadata objects | |
| '<soapenv:Header><a:SdkClientVersion xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">6.0</a:SdkClientVersion></soapenv:Header>', | |
| "<soapenv:Body>", | |
| '<Execute xmlns="http://schemas.microsoft.com/xrm/2011/Contracts/Services" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">', | |
| '<request i:type="a:RetrieveEntityRequest" xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">', | |
| '<a:Parameters xmlns:b="http://schemas.datacontract.org/2004/07/System.Collections.Generic">', | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>EntityFilters</b:key>", | |
| '<b:value i:type="c:EntityFilters" xmlns:c="http://schemas.microsoft.com/xrm/2011/Metadata">' + | |
| _this._xmlEncode(entityFiltersValue) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>MetadataId</b:key>", | |
| '<b:value i:type="ser:guid" xmlns:ser="http://schemas.microsoft.com/2003/10/Serialization/">' + | |
| _this._xmlEncode(MetadataId) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>RetrieveAsIfPublished</b:key>", | |
| '<b:value i:type="c:boolean" xmlns:c="http://www.w3.org/2001/XMLSchema">' + | |
| _this._xmlEncode(true.toString()) + | |
| "</b:value>", | |
| "</a:KeyValuePairOfstringanyType>", | |
| "<a:KeyValuePairOfstringanyType>", | |
| "<b:key>LogicalName</b:key>", | |
| entityLogicalNameValueNode, | |
| "</a:KeyValuePairOfstringanyType>", | |
| "</a:Parameters>", | |
| '<a:RequestId i:nil="true" />', | |
| "<a:RequestName>RetrieveEntity</a:RequestName>", | |
| "</request>", | |
| "</Execute>", | |
| "</soapenv:Body>", | |
| "</soapenv:Envelope>" | |
| ].join(""); | |
| const req = new XMLHttpRequest(); | |
| req.open( | |
| "POST", | |
| _this.getUrl() + "/XRMServices/2011/Organization.svc/web", | |
| true | |
| ); | |
| try { | |
| req.responseType = "msxml-document" as any; | |
| } catch (e) {} | |
| req.setRequestHeader("Accept", "application/xml, text/xml, */*"); | |
| req.setRequestHeader("Content-Type", "text/xml; charset=utf-8"); | |
| req.setRequestHeader( | |
| "SOAPAction", | |
| "http://schemas.microsoft.com/xrm/2011/Contracts/Services/IOrganizationService/Execute" | |
| ); | |
| req.onreadystatechange = function() { | |
| const __this = _this; | |
| if (req.readyState === 4 /* complete */) { | |
| req.onreadystatechange = null; // Addresses potential memory leak issue with IE | |
| if (req.status === 200) { | |
| const doc = req.responseXML; | |
| try { | |
| __this._setSelectionNamespaces(doc); | |
| } catch (e) {} | |
| const a: XrmMetaEntity = __this._objectifyNode(__this._selectSingleNode(doc, "//b:value")); | |
| a._type = "EntityMetadata"; | |
| successCallBack(a); | |
| } else { | |
| // Failure | |
| errorCallBack(__this._getError(req)); | |
| } | |
| } | |
| }; | |
| req.send(request); | |
| } | |
| private _getError(resp) { | |
| const _this = this; | |
| if (resp.status === 12029) { | |
| return new Error("The attempt to connect to the server failed."); | |
| } | |
| if (resp.status === 12007) { | |
| return new Error("The server name could not be resolved."); | |
| } | |
| const faultXml = resp.responseXML; | |
| let errorMessage = "Unknown (unable to parse the fault)"; | |
| let faultstring = null; | |
| let ErrorCode = null; | |
| if (typeof faultXml === "object") { | |
| const bodyNode = faultXml.firstChild.firstChild; | |
| // Retrieve the fault node | |
| for (let i = 0; i < bodyNode.childNodes.length; i++) { | |
| const node = bodyNode.childNodes[i]; | |
| // NOTE: This comparison does not handle the case where the XML namespace changes | |
| if ("s:Fault" === node.nodeName) { | |
| for (let j = 0; j < node.childNodes.length; j++) { | |
| const testNode = node.childNodes[j]; | |
| if ("faultstring" === testNode.nodeName) { | |
| faultstring = _this._getNodeText(testNode); | |
| } | |
| if ("detail" === testNode.nodeName) { | |
| for (let k = 0; k < testNode.childNodes.length; k++) { | |
| const orgServiceFault = testNode.childNodes[k]; | |
| if ("OrganizationServiceFault" === orgServiceFault.nodeName) { | |
| for (let l = 0; l < orgServiceFault.childNodes.length; l++) { | |
| const ErrorCodeNode = orgServiceFault.childNodes[l]; | |
| if ("ErrorCode" === ErrorCodeNode.nodeName) { | |
| ErrorCode = _this._getNodeText(ErrorCodeNode); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| if (ErrorCode != null && faultstring != null) { | |
| errorMessage = "Error Code:" + ErrorCode + " Message: " + faultstring; | |
| } else { | |
| if (faultstring != null) { | |
| errorMessage = faultstring; | |
| } | |
| } | |
| return new Error(errorMessage); | |
| } | |
| private _evaluateEntityFilters(EntityFilters) { | |
| const entityFilterArray = []; | |
| if ((1 & EntityFilters) === 1) { | |
| entityFilterArray.push("Entity"); | |
| } | |
| if ((2 & EntityFilters) === 2) { | |
| entityFilterArray.push("Attributes"); | |
| } | |
| if ((4 & EntityFilters) === 4) { | |
| entityFilterArray.push("Privileges"); | |
| } | |
| if ((8 & EntityFilters) === 8) { | |
| entityFilterArray.push("Relationships"); | |
| } | |
| return entityFilterArray.join(" "); | |
| } | |
| private _isMetadataArray(elementName) { | |
| const _this = this; | |
| for (let i = 0; i < _this._arrayElements.length; i++) { | |
| if (elementName === _this._arrayElements[i]) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| private _objectifyNode(node) { | |
| const _this = this; | |
| // Check for null | |
| if (node.attributes != null && node.attributes.length === 1) { | |
| if ( | |
| node.attributes.getNamedItem("i:nil") != null && | |
| node.attributes.getNamedItem("i:nil").nodeValue === "true" | |
| ) { | |
| return null; | |
| } | |
| } | |
| // Check if it is a value | |
| if (node.firstChild != null && node.firstChild.nodeType === 3) { | |
| const nodeName = _this._getNodeName(node); | |
| switch (nodeName) { | |
| // Integer Values | |
| case "ActivityTypeMask": | |
| case "ObjectTypeCode": | |
| case "ColumnNumber": | |
| case "DefaultFormValue": | |
| case "MaxValue": | |
| case "MinValue": | |
| case "MaxLength": | |
| case "Order": | |
| case "Precision": | |
| case "PrecisionSource": | |
| case "LanguageCode": | |
| return parseInt(node.firstChild.nodeValue, 10); | |
| // Boolean values | |
| case "AutoRouteToOwnerQueue": | |
| case "CanBeChanged": | |
| case "CanTriggerWorkflow": | |
| case "IsActivity": | |
| case "IsAIRUpdated": | |
| case "IsActivityParty": | |
| case "IsAvailableOffline": | |
| case "IsChildEntity": | |
| case "IsCustomEntity": | |
| case "IsCustomOptionSet": | |
| case "IsDocumentManagementEnabled": | |
| case "IsEnabledForCharts": | |
| case "IsGlobal": | |
| case "IsImportable": | |
| case "IsIntersect": | |
| case "IsManaged": | |
| case "IsReadingPaneEnabled": | |
| case "IsValidForAdvancedFind": | |
| case "CanBeSecuredForCreate": | |
| case "CanBeSecuredForRead": | |
| case "CanBeSecuredForUpdate": | |
| case "IsCustomAttribute": | |
| case "IsManaged": | |
| case "IsPrimaryId": | |
| case "IsPrimaryName": | |
| case "IsSecured": | |
| case "IsValidForCreate": | |
| case "IsValidForRead": | |
| case "IsValidForUpdate": | |
| case "IsCustomRelationship": | |
| case "CanBeBasic": | |
| case "CanBeDeep": | |
| case "CanBeGlobal": | |
| case "CanBeLocal": | |
| return node.firstChild.nodeValue === "true" ? true : false; | |
| // OptionMetadata.Value and BooleanManagedProperty.Value and AttributeRequiredLevelManagedProperty.Value | |
| case "Value": | |
| // BooleanManagedProperty.Value | |
| if ( | |
| node.firstChild.nodeValue === "true" || | |
| node.firstChild.nodeValue === "false" | |
| ) { | |
| return node.firstChild.nodeValue === "true" ? true : false; | |
| } | |
| // AttributeRequiredLevelManagedProperty.Value | |
| if ( | |
| node.firstChild.nodeValue === "ApplicationRequired" || | |
| node.firstChild.nodeValue === "None" || | |
| node.firstChild.nodeValue === "Recommended" || | |
| node.firstChild.nodeValue === "SystemRequired" | |
| ) { | |
| return node.firstChild.nodeValue; | |
| } | |
| const numberValue = parseInt(node.firstChild.nodeValue, 10); | |
| if (isNaN(numberValue)) { | |
| // FormatName.Value | |
| return node.firstChild.nodeValue; | |
| } else { | |
| // OptionMetadata.Value | |
| return numberValue; | |
| } | |
| break; | |
| // String values | |
| default: | |
| return node.firstChild.nodeValue; | |
| } | |
| } | |
| // Check if it is a known array | |
| if (_this._isMetadataArray(_this._getNodeName(node))) { | |
| const arrayValue = []; | |
| for (let i = 0; i < node.childNodes.length; i++) { | |
| let objectTypeName; | |
| if ( | |
| node.childNodes[i].attributes != null && | |
| node.childNodes[i].attributes.getNamedItem("i:type") != null | |
| ) { | |
| objectTypeName = node.childNodes[i].attributes | |
| .getNamedItem("i:type") | |
| .nodeValue.split(":")[1]; | |
| } else { | |
| objectTypeName = _this._getNodeName(node.childNodes[i]); | |
| } | |
| const b = _this._objectifyNode(node.childNodes[i]); | |
| b._type = objectTypeName; | |
| arrayValue.push(b); | |
| } | |
| return arrayValue; | |
| } | |
| // Null entity description labels are returned as <label/> - not using i:nil = true; | |
| if (node.childNodes.length === 0) { | |
| return null; | |
| } | |
| // Otherwise return an object | |
| const c: any = {}; | |
| if (node.attributes.getNamedItem("i:type") != null) { | |
| c._type = node.attributes.getNamedItem("i:type").nodeValue.split(":")[1]; | |
| } | |
| for (let i = 0; i < node.childNodes.length; i++) { | |
| if (node.childNodes[i].nodeType === 3) { | |
| c[_this._getNodeName(node.childNodes[i])] = node.childNodes[i].nodeValue; | |
| } else { | |
| c[_this._getNodeName(node.childNodes[i])] = _this._objectifyNode( | |
| node.childNodes[i] | |
| ); | |
| } | |
| } | |
| return c; | |
| } | |
| private _selectNodes(node, XPathExpression) { | |
| const _this = this; | |
| if (typeof node.selectNodes !== "undefined") { | |
| return node.selectNodes(XPathExpression); | |
| } else { | |
| const output = []; | |
| const XPathResults = node.evaluate( | |
| XPathExpression, | |
| node, | |
| _this._NSResolver, | |
| XPathResult.ANY_TYPE, | |
| null | |
| ); | |
| let result = XPathResults.iterateNext(); | |
| while (result) { | |
| output.push(result); | |
| result = XPathResults.iterateNext(); | |
| } | |
| return output; | |
| } | |
| } | |
| private _selectSingleNode(node, xpathExpr) { | |
| const _this = this; | |
| if (typeof node.selectSingleNode !== "undefined") { | |
| return node.selectSingleNode(xpathExpr); | |
| } else { | |
| const xpe = new XPathEvaluator(); | |
| const xPathNode = xpe.evaluate( | |
| xpathExpr, | |
| node, | |
| _this._NSResolver, | |
| XPathResult.FIRST_ORDERED_NODE_TYPE, | |
| null | |
| ); | |
| return xPathNode != null ? xPathNode.singleNodeValue : null; | |
| } | |
| } | |
| private _selectSingleNodeText(node, xpathExpr) { | |
| const _this = this; | |
| const x = _this._selectSingleNode(node, xpathExpr); | |
| if (_this._isNodeNull(x)) { | |
| return null; | |
| } | |
| if (typeof x.text !== "undefined") { | |
| return x.text; | |
| } else { | |
| return x.textContent; | |
| } | |
| } | |
| private _getNodeText(node) { | |
| if (typeof node.text !== "undefined") { | |
| return node.text; | |
| } else { | |
| return node.textContent; | |
| } | |
| } | |
| private _isNodeNull(node) { | |
| if (node == null) { | |
| return true; | |
| } | |
| if ( | |
| node.attributes.getNamedItem("i:nil") != null && | |
| node.attributes.getNamedItem("i:nil").value === "true" | |
| ) { | |
| return true; | |
| } | |
| return false; | |
| } | |
| private _getNodeName(node) { | |
| if (typeof node.baseName !== "undefined") { | |
| return node.baseName; | |
| } else { | |
| return node.localName; | |
| } | |
| } | |
| private _setSelectionNamespaces(doc) { | |
| const namespaces = [ | |
| "xmlns:s='http://schemas.xmlsoap.org/soap/envelope/'", | |
| "xmlns:a='http://schemas.microsoft.com/xrm/2011/Contracts'", | |
| "xmlns:i='http://www.w3.org/2001/XMLSchema-instance'", | |
| "xmlns:b='http://schemas.datacontract.org/2004/07/System.Collections.Generic'", | |
| "xmlns:c='http://schemas.microsoft.com/xrm/2011/Metadata'" | |
| ]; | |
| doc.setProperty("SelectionNamespaces", namespaces.join(" ")); | |
| } | |
| private _NSResolver(prefix) { | |
| const ns = { | |
| s: "http://schemas.xmlsoap.org/soap/envelope/", | |
| a: "http://schemas.microsoft.com/xrm/2011/Contracts", | |
| i: "http://www.w3.org/2001/XMLSchema-instance", | |
| b: "http://schemas.datacontract.org/2004/07/System.Collections.Generic", | |
| c: "http://schemas.microsoft.com/xrm/2011/Metadata" | |
| }; | |
| return ns[prefix] || null; | |
| } | |
| private _xmlEncode(strInput) { | |
| let c; | |
| let XmlEncode = ""; | |
| if (strInput == null) { | |
| return null; | |
| } | |
| if (strInput === "") { | |
| return ""; | |
| } | |
| for (let cnt = 0; cnt < strInput.length; cnt++) { | |
| c = strInput.charCodeAt(cnt); | |
| if ( | |
| (c > 96 && c < 123) || | |
| (c > 64 && c < 91) || | |
| c === 32 || | |
| (c > 47 && c < 58) || | |
| c === 46 || | |
| c === 44 || | |
| c === 45 || | |
| c === 95 | |
| ) { | |
| XmlEncode = XmlEncode + String.fromCharCode(c); | |
| } else { | |
| XmlEncode = XmlEncode + "&#" + c + ";"; | |
| } | |
| } | |
| return XmlEncode; | |
| } | |
| //#endregion | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment