@jaricardodev/ews-javascript-api
Version:
EWS Managed api in JavaScript
1,044 lines (1,043 loc) • 2.75 MB
text/typescript
module exclusion {
class AttachableAttribute extends Attribute
{
constructor()
{
super();
}
}
class EwsEnumAttribute extends Attribute
{
private schemaName: string = null;
get SchemaName(): string
{
return this.schemaName;
}
constructor(schemaName: string)
{
super();
this.schemaName = schemaName;
}
}
class RequiredServerVersionAttribute extends Attribute
{
private version: ExchangeVersion = 0;
get Version(): ExchangeVersion
{
return this.version;
}
constructor(version: ExchangeVersion)
{
super();
this.version = version;
}
}
class SchemaAttribute extends Attribute
{
constructor()
{
super();
}
}
class ServiceObjectDefinitionAttribute extends Attribute
{
private xmlElementName: string = null;
private returnedByServer: boolean = false;
get XmlElementName(): string
{
return this.xmlElementName;
}
set ReturnedByServer(value: boolean)
{
this.returnedByServer = value;
}
get ReturnedByServer(): boolean
{
return this.returnedByServer;
}
constructor(xmlElementName: string)
{
super();
this.xmlElementName = xmlElementName;
this.returnedByServer = true;
}
}
class ExchangeServiceBase {
static AccountIsLocked: HttpStatusCode = <HttpStatusCode>456;
private static lockObj: any = new any();
private requestedServerVersion: ExchangeVersion = ExchangeVersion.Exchange2013_SP1;
private static binarySecret: number[] = null;
private static defaultUserAgent: string = "ExchangeServicesClient/" + EwsUtilities.BuildVersion;
private credentials: ExchangeCredentials = null;
private useDefaultCredentials: boolean = false;
private timeout: number = 100000;
private traceEnabled: boolean = false;
private sendClientLatencies: boolean = true;
private traceFlags: TraceFlags = TraceFlags.All;
private traceListener: ITraceListener = new EwsTraceListener();
private preAuthenticate: boolean = false;
private userAgent: string = ExchangeServiceBase.defaultUserAgent;
private acceptGzipEncoding: boolean = true;
private keepAlive: boolean = true;
private connectionGroupName: string = null;
private clientRequestId: string = null;
private returnClientRequestId: boolean = false;
private cookieContainer: CookieContainer = new CookieContainer();
private timeZone: TimeZoneInfo = null;
private timeZoneDefinition: TimeZoneDefinition = null;
private serverInfo: ExchangeServerInfo = null;
private webProxy: IWebProxy = null;
private httpHeaders: IDictionary<string, string> = new Dictionary<string, string>();
private httpResponseHeaders: IDictionary<string, string> = new Dictionary<string, string>();
private ewsHttpWebRequestFactory: IEwsHttpWebRequestFactory = new EwsHttpWebRequestFactory();
OnResponseHeadersCaptured: NEvent<(responseHeaders: WebHeaderCollection) => void> = new NEvent<(responseHeaders: WebHeaderCollection) => void>();
OnSerializeCustomSoapHeaders: NEvent<(writer: XmlWriter) => void> = new NEvent<(writer: XmlWriter) => void>();
set CookieContainer(value: CookieContainer) {
this.cookieContainer = value;
}
get CookieContainer(): CookieContainer {
return this.cookieContainer;
}
get TimeZone(): TimeZoneInfo {
return this.timeZone;
}
get TimeZoneDefinition(): TimeZoneDefinition {
if (this.timeZoneDefinition === null) {
this.timeZoneDefinition = new TimeZoneDefinition(this.TimeZone);
}
return this.timeZoneDefinition;
}
set SendClientLatencies(value: boolean) {
this.sendClientLatencies = value;
}
get SendClientLatencies(): boolean {
return this.sendClientLatencies;
}
set TraceEnabled(value: boolean) {
this.traceEnabled = value;
if (this.traceEnabled && this.traceListener === null) {
this.traceListener = new EwsTraceListener();
}
}
get TraceEnabled(): boolean {
return this.traceEnabled;
}
set TraceFlags(value: TraceFlags) {
this.traceFlags = value;
}
get TraceFlags(): TraceFlags {
return this.traceFlags;
}
set TraceListener(value: ITraceListener) {
this.traceListener = value;
this.traceEnabled = (value !== null);
}
get TraceListener(): ITraceListener {
return this.traceListener;
}
set Credentials(value: ExchangeCredentials) {
this.credentials = value;
this.useDefaultCredentials = false;
this.cookieContainer = new CookieContainer();
}
get Credentials(): ExchangeCredentials {
return this.credentials;
}
set UseDefaultCredentials(value: boolean) {
this.useDefaultCredentials = value;
if (value) {
this.credentials = null;
this.cookieContainer = new CookieContainer();
}
}
get UseDefaultCredentials(): boolean {
return this.useDefaultCredentials;
}
set Timeout(value: number) {
if (value < 1) {
throw new ArgumentException(Strings.TimeoutMustBeGreaterThanZero);
}
this.timeout = value;
}
get Timeout(): number {
return this.timeout;
}
set PreAuthenticate(value: boolean) {
this.preAuthenticate = value;
}
get PreAuthenticate(): boolean {
return this.preAuthenticate;
}
set AcceptGzipEncoding(value: boolean) {
this.acceptGzipEncoding = value;
}
get AcceptGzipEncoding(): boolean {
return this.acceptGzipEncoding;
}
get RequestedServerVersion(): ExchangeVersion {
return this.requestedServerVersion;
}
set UserAgent(value: string) {
this.userAgent = value + " (" + ExchangeServiceBase.defaultUserAgent + ")";
}
get UserAgent(): string {
return this.userAgent;
}
set ServerInfo(value: ExchangeServerInfo) {
this.serverInfo = value;
}
get ServerInfo(): ExchangeServerInfo {
return this.serverInfo;
}
set WebProxy(value: IWebProxy) {
this.webProxy = value;
}
get WebProxy(): IWebProxy {
return this.webProxy;
}
set KeepAlive(value: boolean) {
this.keepAlive = value;
}
get KeepAlive(): boolean {
return this.keepAlive;
}
set ConnectionGroupName(value: string) {
this.connectionGroupName = value;
}
get ConnectionGroupName(): string {
return this.connectionGroupName;
}
set ClientRequestId(value: string) {
this.clientRequestId = value;
}
get ClientRequestId(): string {
return this.clientRequestId;
}
set ReturnClientRequestId(value: boolean) {
this.returnClientRequestId = value;
}
get ReturnClientRequestId(): boolean {
return this.returnClientRequestId;
}
get HttpHeaders(): IDictionary<string, string> {
return this.httpHeaders;
}
get HttpResponseHeaders(): IDictionary<string, string> {
return this.httpResponseHeaders;
}
static get SessionKey(): number[] {
var obj: any;
Monitor.Enter(obj = ExchangeServiceBase.lockObj);
var result: number[];
try {
if (ExchangeServiceBase.binarySecret === null) {
var randomNumberGenerator: RandomNumberGenerator = RandomNumberGenerator.Create();
ExchangeServiceBase.binarySecret = new Array<number>(32);
for (var _ai: number = 0; _ai < ExchangeServiceBase.binarySecret.length; ++_ai)
ExchangeServiceBase.binarySecret[_ai] = 0;
randomNumberGenerator.GetNonZeroBytes(ExchangeServiceBase.binarySecret);
}
result = ExchangeServiceBase.binarySecret;
}
finally {
Monitor.Exit(obj);
}
return result;
}
set HttpWebRequestFactory(value: IEwsHttpWebRequestFactory) {
this.ewsHttpWebRequestFactory = ((value === null) ? new EwsHttpWebRequestFactory() : value);
}
get HttpWebRequestFactory(): IEwsHttpWebRequestFactory {
return this.ewsHttpWebRequestFactory;
}
SuppressXmlVersionHeader: boolean = false;
DoOnSerializeCustomSoapHeaders(writer: XmlWriter): void {
EwsUtilities.Assert(writer !== null, "ExchangeService.DoOnSerializeCustomSoapHeaders", "writer is null");
if (this.OnSerializeCustomSoapHeaders !== null) {
this.OnSerializeCustomSoapHeaders(writer);
}
}
PrepareHttpWebRequestForUrl(url: Uri, acceptGzipEncoding: boolean, allowAutoRedirect: boolean): IEwsHttpWebRequest {
if (url.Scheme !== Uri.UriSchemeHttp && url.Scheme !== Uri.UriSchemeHttps) {
throw new ServiceLocalException(NString.Format(Strings.UnsupportedWebProtocol, url.Scheme));
}
var request: IEwsHttpWebRequest = this.HttpWebRequestFactory.CreateRequest(url);
request.PreAuthenticate = this.PreAuthenticate;
request.Timeout = this.Timeout;
this.SetContentType(request);
request.Method = "POST";
request.UserAgent = this.UserAgent;
request.AllowAutoRedirect = allowAutoRedirect;
request.CookieContainer = this.CookieContainer;
request.KeepAlive = this.keepAlive;
request.ConnectionGroupName = this.connectionGroupName;
if (acceptGzipEncoding) {
request.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip,deflate");
}
if (!NString.IsNullOrEmpty(this.clientRequestId)) {
request.Headers.Add("client-request-id", this.clientRequestId);
if (this.returnClientRequestId) {
request.Headers.Add("return-client-request-id", "true");
}
}
if (this.webProxy !== null) {
request.Proxy = this.webProxy;
}
if (this.HttpHeaders.Count > 0) {
EwsUtilities.ForEach<KeyValuePair<string, string>>(this.HttpHeaders, (kv: KeyValuePair<string, string>) => {
request.Headers.Add(kv.Key, kv.Value);
});
}
request.UseDefaultCredentials = this.UseDefaultCredentials;
if (!request.UseDefaultCredentials) {
var exchangeCredentials: ExchangeCredentials = this.Credentials;
if (exchangeCredentials === null) {
throw new ServiceLocalException(Strings.CredentialsRequired);
}
exchangeCredentials.PreAuthenticate();
exchangeCredentials.PrepareWebRequest(request);
}
this.httpResponseHeaders.Clear();
return request;
}
SetContentType(request: IEwsHttpWebRequest): void {
request.ContentType = "text/xml; charset=utf-8";
request.Accept = "text/xml";
}
InternalProcessHttpErrorResponse(httpWebResponse: IEwsHttpWebResponse, webException: WebException, responseHeadersTraceFlag: TraceFlags, responseTraceFlag: TraceFlags): void {
EwsUtilities.Assert(httpWebResponse.StatusCode !== HttpStatusCode.InternalServerError, "ExchangeServiceBase.InternalProcessHttpErrorResponse", "InternalProcessHttpErrorResponse does not handle 500 ISE errors, the caller is supposed to handle this.");
this.ProcessHttpResponseHeaders(responseHeadersTraceFlag, httpWebResponse);
if (httpWebResponse.StatusCode === <HttpStatusCode>456) {
var statusDescription: string = httpWebResponse.StatusDescription;
var uri: Uri = null;
if (Uri.IsWellFormedUriString(statusDescription, UriKind.Absolute)) {
uri = new Uri(statusDescription);
}
this.TraceMessage(responseTraceFlag, NString.Format("Account is locked. Unlock URL is {0}", uri));
throw new AccountIsLockedException(NString.Format(Strings.AccountIsLocked, uri), uri, webException);
}
}
ProcessHttpErrorResponse(httpWebResponse: IEwsHttpWebResponse, webException: WebException): void {
throw new NotSupportedException();
}
IsTraceEnabledFor(traceFlags: TraceFlags): boolean {
return this.TraceEnabled && (this.TraceFlags & traceFlags) !== TraceFlags.None;
}
TraceMessage(traceType: TraceFlags, logEntry: string): void {
if (this.IsTraceEnabledFor(traceType)) {
var text: string = TraceFlags[traceType];
var traceMessage: string = EwsUtilities.FormatLogMessage(text, logEntry);
this.TraceListener.Trace(text, traceMessage);
}
}
TraceXml(traceType: TraceFlags, stream: MemoryStream): void {
if (this.IsTraceEnabledFor(traceType)) {
var text: string = TraceFlags[traceType];
var traceMessage: string = EwsUtilities.FormatLogMessageWithXmlContent(text, stream);
this.TraceListener.Trace(text, traceMessage);
}
}
TraceHttpRequestHeaders(traceType: TraceFlags, request: IEwsHttpWebRequest): void {
if (this.IsTraceEnabledFor(traceType)) {
var text: string = TraceFlags[traceType];
var logEntry: string = EwsUtilities.FormatHttpRequestHeaders(request);
var traceMessage: string = EwsUtilities.FormatLogMessage(text, logEntry);
this.TraceListener.Trace(text, traceMessage);
}
}
ProcessHttpResponseHeaders(traceType: TraceFlags, response: IEwsHttpWebResponse): void {
this.TraceHttpResponseHeaders(traceType, response);
this.SaveHttpResponseHeaders(response.Headers);
}
private TraceHttpResponseHeaders(traceType: TraceFlags, response: IEwsHttpWebResponse): void {
if (this.IsTraceEnabledFor(traceType)) {
var text: string = TraceFlags[traceType];
var logEntry: string = EwsUtilities.FormatHttpResponseHeaders(response);
var traceMessage: string = EwsUtilities.FormatLogMessage(text, logEntry);
this.TraceListener.Trace(text, traceMessage);
}
}
private SaveHttpResponseHeaders(headers: WebHeaderCollection): void {
EwsUtilities.Assert(this.httpResponseHeaders.Count === 0, "ExchangeServiceBase.SaveHttpResponseHeaders", "expect no headers in the dictionary yet.");
this.httpResponseHeaders.Clear();
var allKeys: string[] = headers.AllKeys;
for (var i: number = 0; i < allKeys.length; i = i + 1) {
var text: string = allKeys[i];
this.httpResponseHeaders.Add(text, headers.get_Item(text));
}
if (this.OnResponseHeadersCaptured !== null) {
this.OnResponseHeadersCaptured(headers);
}
}
ConvertUniversalDateTimeStringToLocalDateTime(value: string): Nullable<DateTime> {
if (NString.IsNullOrEmpty(value)) {
return null;
}
var dateTime: DateTime = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
if (this.TimeZone === TimeZoneInfo.Utc) {
return new Nullable<DateTime>(dateTime);
}
var value2: DateTime = EwsUtilities.ConvertTime(dateTime, TimeZoneInfo.Utc, this.TimeZone);
if (EwsUtilities.IsLocalTimeZone(this.TimeZone)) {
return new Nullable<DateTime>(new DateTime(value2.Ticks, DateTimeKind.Local));
}
return new Nullable<DateTime>(value2);
}
ConvertStartDateToUnspecifiedDateTime(value: string): Nullable<DateTime> {
if (NString.IsNullOrEmpty(value)) {
return null;
}
return new Nullable<DateTime>(DateTimeOffset.Parse(value, CultureInfo.InvariantCulture).Date);
}
ConvertDateTimeToUniversalDateTimeString(value: DateTime): string {
var IL_45: number = 1;
var _goto: number = 0;
_GOTO_LOOP:
while (true) {
switch (_goto) {
default:
var dateTime: DateTime;
switch (value.Kind) {
case DateTimeKind.Unspecified:
dateTime = EwsUtilities.ConvertTime(value, this.TimeZone, TimeZoneInfo.Utc);
_goto = IL_45;
continue _GOTO_LOOP;
case DateTimeKind.Local:
dateTime = EwsUtilities.ConvertTime(value, TimeZoneInfo.Local, TimeZoneInfo.Utc);
_goto = IL_45;
continue _GOTO_LOOP;
}
dateTime = value;
_goto = IL_45;
continue _GOTO_LOOP;
case 1:
return dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffZ", CultureInfo.InvariantCulture);
}
}
}
SetCustomUserAgent(userAgent: string): void {
this.userAgent = userAgent;
}
constructor();
constructor(timeZone: TimeZoneInfo);
constructor(requestedServerVersion: ExchangeVersion);
constructor(requestedServerVersion: ExchangeVersion, timeZone: TimeZoneInfo);
constructor(service: ExchangeServiceBase, requestedServerVersion: ExchangeVersion);
constructor(service: ExchangeServiceBase);
constructor(timeZoneOrRequestedServerVersionOrService?: any, timeZoneOrRequestedServerVersion?: any) {
super();
if (arguments.length === 0) {
this.constructor_0();
return;
}
if (arguments.length === 1 && (timeZoneOrRequestedServerVersionOrService === null || timeZoneOrRequestedServerVersionOrService instanceof TimeZoneInfo)) {
this.constructor_1(timeZoneOrRequestedServerVersionOrService);
return;
}
if (arguments.length === 1 && (timeZoneOrRequestedServerVersionOrService === null || timeZoneOrRequestedServerVersionOrService.constructor === Number)) {
this.constructor_2(timeZoneOrRequestedServerVersionOrService);
return;
}
if (arguments.length === 2 && (timeZoneOrRequestedServerVersionOrService === null || timeZoneOrRequestedServerVersionOrService.constructor === Number) && (timeZoneOrRequestedServerVersion === null || timeZoneOrRequestedServerVersion instanceof TimeZoneInfo)) {
this.constructor_3(timeZoneOrRequestedServerVersionOrService, timeZoneOrRequestedServerVersion);
return;
}
if (arguments.length === 2 && (timeZoneOrRequestedServerVersionOrService === null || timeZoneOrRequestedServerVersionOrService instanceof ExchangeServiceBase) && (timeZoneOrRequestedServerVersion === null || timeZoneOrRequestedServerVersion.constructor === Number)) {
this.constructor_4(timeZoneOrRequestedServerVersionOrService, timeZoneOrRequestedServerVersion);
return;
}
this.constructor_5(timeZoneOrRequestedServerVersionOrService);
}
private constructor_0(): void {
this.constructor_1(TimeZoneInfo.Local);
}
private constructor_1(timeZone: TimeZoneInfo): void {
this.timeZone = timeZone;
this.UseDefaultCredentials = true;
}
private constructor_2(requestedServerVersion: ExchangeVersion): void {
this.constructor_3(requestedServerVersion, TimeZoneInfo.Local);
}
private constructor_3(requestedServerVersion: ExchangeVersion, timeZone: TimeZoneInfo): void {
this.constructor_1(timeZone);
this.requestedServerVersion = requestedServerVersion;
}
private constructor_4(service: ExchangeServiceBase, requestedServerVersion: ExchangeVersion): void {
this.constructor_2(requestedServerVersion);
this.useDefaultCredentials = service.useDefaultCredentials;
this.credentials = service.credentials;
this.traceEnabled = service.traceEnabled;
this.traceListener = service.traceListener;
this.traceFlags = service.traceFlags;
this.timeout = service.timeout;
this.preAuthenticate = service.preAuthenticate;
this.userAgent = service.userAgent;
this.acceptGzipEncoding = service.acceptGzipEncoding;
this.keepAlive = service.keepAlive;
this.connectionGroupName = service.connectionGroupName;
this.timeZone = service.timeZone;
this.httpHeaders = service.httpHeaders;
this.ewsHttpWebRequestFactory = service.ewsHttpWebRequestFactory;
}
private constructor_5(service: ExchangeServiceBase): void {
this.constructor_4(service, service.RequestedServerVersion);
}
Validate(): void {
}
}
interface ISelfValidate {
Validate(): void;
}
interface IJsonSerializable {
ToJson(service: ExchangeService): any;
}
class ComplexProperty implements ISelfValidate, IJsonSerializable {
private xmlNamespace: XmlNamespace = XmlNamespace.Types;
OnChange: NEvent<(complexProperty: ComplexProperty) => void> = new NEvent<(complexProperty: ComplexProperty) => void>();
set Namespace(value: XmlNamespace) {
this.xmlNamespace = value;
}
get Namespace(): XmlNamespace {
return this.xmlNamespace;
}
constructor() {
super();
}
Changed(): void {
if (this.OnChange !== null) {
this.OnChange(this);
}
}
SetFieldValue<T>(field: T[], value: T): void {
var flag: boolean;
if (field[0] === null) {
flag = (value !== null);
}
else {
flag = (!(field[0] instanceof IComparable) || (((field[0] instanceof IComparable) ? <IComparable>field[0] : null)).CompareTo(value) !== 0);
}
if (flag) {
field[0] = value;
this.Changed();
}
}
ClearChangeLog(): void {
}
ReadAttributesFromXml(reader: EwsServiceXmlReader): void {
}
ReadTextValueFromXml(reader: EwsServiceXmlReader): void {
}
TryReadElementFromXml(reader: EwsServiceXmlReader): boolean {
return false;
}
TryReadElementFromXmlToPatch(reader: EwsServiceXmlReader): boolean {
return false;
}
WriteAttributesToXml(writer: EwsServiceXmlWriter): void {
}
WriteElementsToXml(writer: EwsServiceXmlWriter): void {
}
LoadFromXml(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string): void;
LoadFromXml(reader: EwsServiceXmlReader, xmlElementName: string): void;
LoadFromXml(reader: EwsServiceXmlReader, xmlNamespaceOrXmlElementName: any, xmlElementName?: string): void {
if (arguments.length === 3 && (reader === null || reader instanceof EwsServiceXmlReader) && (xmlNamespaceOrXmlElementName === null || xmlNamespaceOrXmlElementName.constructor === Number) && (xmlElementName === null || xmlElementName.constructor === String)) {
this.LoadFromXml_0(reader, xmlNamespaceOrXmlElementName, xmlElementName);
return;
}
this.LoadFromXml_1(reader, xmlNamespaceOrXmlElementName);
}
private LoadFromXml_0(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string): void {
this.InternalLoadFromXml(reader, xmlNamespace, xmlElementName, this.TryReadElementFromXml);
}
UpdateFromXml(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string): void;
UpdateFromXml(reader: EwsServiceXmlReader, xmlElementName: string): void;
UpdateFromXml(reader: EwsServiceXmlReader, xmlNamespaceOrXmlElementName: any, xmlElementName?: string): void {
if (arguments.length === 3 && (reader === null || reader instanceof EwsServiceXmlReader) && (xmlNamespaceOrXmlElementName === null || xmlNamespaceOrXmlElementName.constructor === Number) && (xmlElementName === null || xmlElementName.constructor === String)) {
this.UpdateFromXml_0(reader, xmlNamespaceOrXmlElementName, xmlElementName);
return;
}
this.UpdateFromXml_1(reader, xmlNamespaceOrXmlElementName);
}
private UpdateFromXml_0(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string): void {
this.InternalLoadFromXml(reader, xmlNamespace, xmlElementName, this.TryReadElementFromXmlToPatch);
}
private InternalLoadFromXml(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string, readAction: (arg: EwsServiceXmlReader) => boolean): void {
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, xmlElementName);
this.ReadAttributesFromXml(reader);
if (!reader.IsEmptyElement) {
do {
reader.Read();
switch (reader.NodeType) {
case 1:
if (!readAction(reader)) {
reader.SkipCurrentElement();
}
break;
case 3:
this.ReadTextValueFromXml(reader);
break;
}
}
while (!reader.IsEndElement(xmlNamespace, xmlElementName));
}
}
private LoadFromXml_1(reader: EwsServiceXmlReader, xmlElementName: string): void {
this.LoadFromXml(reader, this.Namespace, xmlElementName);
}
private UpdateFromXml_1(reader: EwsServiceXmlReader, xmlElementName: string): void {
this.UpdateFromXml(reader, this.Namespace, xmlElementName);
}
LoadFromJson(jsonProperty: JsonObject, service: ExchangeService): void {
throw new NotImplementedException();
}
WriteToXml(writer: EwsServiceXmlWriter, xmlNamespace: XmlNamespace, xmlElementName: string): void;
WriteToXml(writer: EwsServiceXmlWriter, xmlElementName: string): void;
WriteToXml(writer: EwsServiceXmlWriter, xmlNamespaceOrXmlElementName: any, xmlElementName?: string): void {
if (arguments.length === 3 && (writer === null || writer instanceof EwsServiceXmlWriter) && (xmlNamespaceOrXmlElementName === null || xmlNamespaceOrXmlElementName.constructor === Number) && (xmlElementName === null || xmlElementName.constructor === String)) {
this.WriteToXml_0(writer, xmlNamespaceOrXmlElementName, xmlElementName);
return;
}
this.WriteToXml_1(writer, xmlNamespaceOrXmlElementName);
}
private WriteToXml_0(writer: EwsServiceXmlWriter, xmlNamespace: XmlNamespace, xmlElementName: string): void {
writer.WriteStartElement(xmlNamespace, xmlElementName);
this.WriteAttributesToXml(writer);
this.WriteElementsToXml(writer);
writer.WriteEndElement();
}
private WriteToXml_1(writer: EwsServiceXmlWriter, xmlElementName: string): void {
this.WriteToXml(writer, this.Namespace, xmlElementName);
}
ToJson(service: ExchangeService): any {
return this.InternalToJson(service);
}
InternalToJson(service: ExchangeService): any {
throw new NotImplementedException();
}
Validate(): void {
this.InternalValidate();
}
InternalValidate(): void {
}
}
class ExtractedEntity extends ComplexProperty {
Position: EmailPosition = 0;
constructor() {
super();
this.Namespace = XmlNamespace.Types;
}
TryReadElementFromXml(reader: EwsServiceXmlReader): boolean {
var localName: string;
if ((localName = reader.LocalName) !== null && localName === "Position") {
var value: string = reader.ReadElementValue();
if (!NString.IsNullOrEmpty(value)) {
this.Position = EwsUtilities.Parse<EmailPosition>(value);
}
return true;
}
return super.TryReadElementFromXml(reader);
}
}
class AddressEntity extends ExtractedEntity {
Address: string = null;
constructor() {
super();
}
TryReadElementFromXml(reader: EwsServiceXmlReader): boolean {
var localName: string;
if ((localName = reader.LocalName) !== null && localName === "Address") {
this.Address = reader.ReadElementValue();
return true;
}
return super.TryReadElementFromXml(reader);
}
}
interface ICustomUpdateSerializer {
WriteSetUpdateToXml(writer: EwsServiceXmlWriter, ewsObject: ServiceObject, propertyDefinition: PropertyDefinition): boolean;
WriteDeleteUpdateToXml(writer: EwsServiceXmlWriter, ewsObject: ServiceObject): boolean;
WriteSetUpdateToJson(service: ExchangeService, ewsObject: ServiceObject, propertyDefinition: PropertyDefinition, updates: List<JsonObject>): boolean;
WriteDeleteUpdateToJson(service: ExchangeService, ewsObject: ServiceObject, updates: List<JsonObject>): boolean;
}
interface IJsonCollectionDeserializer {
CreateFromJsonCollection(jsonCollection: any[], service: ExchangeService): void;
UpdateFromJsonCollection(jsonCollection: any[], service: ExchangeService): void;
}
class ComplexPropertyCollection<TComplexProperty> extends ComplexProperty implements IEnumerable<TComplexProperty>, ICustomUpdateSerializer, IJsonCollectionDeserializer {
private items: List<TComplexProperty> = new List<TComplexProperty>();
private addedItems: List<TComplexProperty> = new List<TComplexProperty>();
private modifiedItems: List<TComplexProperty> = new List<TComplexProperty>();
private removedItems: List<TComplexProperty> = new List<TComplexProperty>();
get Items(): List<TComplexProperty> {
return this.items;
}
get AddedItems(): List<TComplexProperty> {
return this.addedItems;
}
get ModifiedItems(): List<TComplexProperty> {
return this.modifiedItems;
}
get RemovedItems(): List<TComplexProperty> {
return this.removedItems;
}
get Count(): number {
return this.items.Count;
}
get_Item(index: number): TComplexProperty {
if (index < 0 || index >= this.Count) {
throw new ArgumentOutOfRangeException("index", Strings.IndexIsOutOfRange);
}
return this.items.get_Item(index);
}
CreateComplexProperty(xmlElementName: string): TComplexProperty {
throw new NotSupportedException();
}
CreateDefaultComplexProperty(): TComplexProperty {
throw new NotSupportedException();
}
GetCollectionItemXmlElementName(complexProperty: TComplexProperty): string {
throw new NotSupportedException();
}
constructor() {
super();
}
ItemChanged(complexProperty: ComplexProperty): void {
var tComplexProperty: TComplexProperty = ((complexProperty instanceof TComplexProperty) ? <TComplexProperty>complexProperty : null);
EwsUtilities.Assert(tComplexProperty !== null, "ComplexPropertyCollection.ItemChanged", NString.Format("ComplexPropertyCollection.ItemChanged: the type of the complexProperty argument ({0}) is not supported.", complexProperty.GetType().Name));
if (!this.addedItems.Contains(tComplexProperty) && !this.modifiedItems.Contains(tComplexProperty)) {
this.modifiedItems.Add(tComplexProperty);
this.Changed();
}
}
LoadFromXml(reader: EwsServiceXmlReader, localElementName: string): void;
LoadFromXml(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, localElementName: string): void;
LoadFromXml(reader: EwsServiceXmlReader, localElementNameOrXmlNamespace: any, localElementName?: string): void {
if (arguments.length === 2 && (reader === null || reader instanceof EwsServiceXmlReader) && (localElementNameOrXmlNamespace === null || localElementNameOrXmlNamespace.constructor === String)) {
this.LoadFromXml_0(reader, localElementNameOrXmlNamespace);
return;
}
this.LoadFromXml_1(reader, localElementNameOrXmlNamespace, localElementName);
}
private LoadFromXml_0(reader: EwsServiceXmlReader, localElementName: string): void {
this.LoadFromXml(reader, XmlNamespace.Types, localElementName);
}
private LoadFromXml_1(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, localElementName: string): void {
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, localElementName);
if (!reader.IsEmptyElement) {
do {
reader.Read();
if (reader.IsStartElement()) {
var tComplexProperty: TComplexProperty = this.CreateComplexProperty(reader.LocalName);
if (tComplexProperty !== null) {
tComplexProperty.LoadFromXml(reader, reader.LocalName);
this.InternalAdd(tComplexProperty, true);
}
else {
reader.SkipCurrentElement();
}
}
}
while (!reader.IsEndElement(xmlNamespace, localElementName));
}
}
UpdateFromXml(reader: EwsServiceXmlReader, xmlNamespace: XmlNamespace, xmlElementName: string): void {
reader.EnsureCurrentNodeIsStartElement(xmlNamespace, xmlElementName);
if (!reader.IsEmptyElement) {
var num: number = 0;
while (true) {
reader.Read();
if (reader.IsStartElement()) {
var tComplexProperty: TComplexProperty = this.CreateComplexProperty(reader.LocalName);
var tComplexProperty2: TComplexProperty = this.get_Item(num++);
if (tComplexProperty === null || !tComplexProperty.GetType().IsInstanceOfType(tComplexProperty2)) {
break;
}
tComplexProperty2.UpdateFromXml(reader, xmlNamespace, reader.LocalName);
}
if (reader.IsEndElement(xmlNamespace, xmlElementName)) {
return;
}
}
throw new ServiceLocalException(Strings.PropertyTypeIncompatibleWhenUpdatingCollection);
}
}
CreateFromJsonCollection(jsonCollection: any[], service: ExchangeService): void {
for (var i: number = 0; i < jsonCollection.length; i = i + 1) {
var obj: any = jsonCollection[i];
var jsonObject: JsonObject = ((obj instanceof JsonObject) ? <JsonObject>obj : null);
if (jsonObject !== null) {
var tComplexProperty: TComplexProperty = null;
if (jsonObject.HasTypeProperty()) {
tComplexProperty = this.CreateComplexProperty(jsonObject.ReadTypeString());
}
else {
tComplexProperty = this.CreateDefaultComplexProperty();
}
if (tComplexProperty !== null) {
tComplexProperty.LoadFromJson(jsonObject, service);
this.InternalAdd(tComplexProperty, true);
}
}
}
}
UpdateFromJsonCollection(jsonCollection: any[], service: ExchangeService): void {
if (this.Count !== jsonCollection.length) {
throw new ServiceLocalException(Strings.PropertyCollectionSizeMismatch);
}
var num: number = 0;
for (var i: number = 0; i < jsonCollection.length; i = i + 1) {
var obj: any = jsonCollection[i];
var jsonObject: JsonObject = ((obj instanceof JsonObject) ? <JsonObject>obj : null);
if (jsonObject === null) {
throw new ServiceLocalException();
}
var tComplexProperty: TComplexProperty = null;
if (jsonObject.HasTypeProperty()) {
tComplexProperty = this.CreateComplexProperty(jsonObject.ReadTypeString());
}
else {
tComplexProperty = this.CreateDefaultComplexProperty();
}
var tComplexProperty2: TComplexProperty = this.get_Item(num++);
if (tComplexProperty === null || !tComplexProperty.GetType().IsInstanceOfType(tComplexProperty2)) {
throw new ServiceLocalException(Strings.PropertyTypeIncompatibleWhenUpdatingCollection);
}
tComplexProperty2.LoadFromJson(jsonObject, service);
}
}
WriteToXml(writer: EwsServiceXmlWriter, xmlNamespace: XmlNamespace, xmlElementName: string): void {
if (this.ShouldWriteToRequest()) {
super.WriteToXml(writer, xmlNamespace, xmlElementName);
}
}
InternalToJson(service: ExchangeService): any {
var list: List<any> = new List<any>();
var enumerator: IEnumerator<TComplexProperty> = this.GetEnumerator();
try {
while (enumerator.MoveNext()) {
var current: TComplexProperty = enumerator.Current;
list.Add(current.InternalToJson(service));
}
}
finally {
if (enumerator !== null) {
enumerator.Dispose();
}
}
return list.ToArray();
}
ShouldWriteToRequest(): boolean {
return this.Count > 0;
}
WriteElementsToXml(writer: EwsServiceXmlWriter): void {
var enumerator: IEnumerator<TComplexProperty> = this.GetEnumerator();
try {
while (enumerator.MoveNext()) {
var current: TComplexProperty = enumerator.Current;
current.WriteToXml(writer, this.GetCollectionItemXmlElementName(current));
}
}
finally {
if (enumerator !== null) {
enumerator.Dispose();
}
}
}
ClearChangeLog(): void {
this.removedItems.Clear();
this.addedItems.Clear();
this.modifiedItems.Clear();
}
RemoveFromChangeLog(complexProperty: TComplexProperty): void {
this.removedItems.Remove(complexProperty);
this.modifiedItems.Remove(complexProperty);
this.addedItems.Remove(complexProperty);
}
InternalAdd(complexProperty: TComplexProperty): void;
InternalAdd(complexProperty: TComplexProperty, loading: boolean): void;
InternalAdd(complexProperty: TComplexProperty, loading?: boolean): void {
if (arguments.length === 1 && (complexProperty === null || complexProperty instanceof TComplexProperty)) {
this.InternalAdd_0(complexProperty);
return;
}
this.InternalAdd_1(complexProperty, loading);
}
private InternalAdd_0(complexProperty: TComplexProperty): void {
this.InternalAdd(complexProperty, false);
}
private InternalAdd_1(complexProperty: TComplexProperty, loading: boolean): void {
EwsUtilities.Assert(complexProperty !== null, "ComplexPropertyCollection.InternalAdd", "complexProperty is null");
if (!this.items.Contains(complexProperty)) {
this.items.Add(complexProperty);
if (!loading) {
this.removedItems.Remove(complexProperty);
this.addedItems.Add(complexProperty);
}
complexProperty.OnChange.Add(this.ItemChanged);
this.Changed();
}
}
InternalClear(): void {
while (this.Count > 0) {
this.InternalRemoveAt(0);
}
}
InternalRemoveAt(index: number): void {
EwsUtilities.Assert(index >= 0 && index < this.Count, "ComplexPropertyCollection.InternalRemoveAt", "index is out of range.");
this.InternalRemove(this.items.get_Item(index));
}
InternalRemove(complexProperty: TComplexProperty): boolean {
EwsUtilities.Assert(complexProperty !== null, "ComplexPropertyCollection.InternalRemove", "complexProperty is null");
if (this.items.Remove(complexProperty)) {
complexProperty.OnChange.Remove(this.ItemChanged);
if (!this.addedItems.Contains(complexProperty)) {
this.removedItems.Add(complexProperty);
}
else {
this.addedItems.Remove(complexProperty);
}
this.modifiedItems.Remove(complexProperty);
this.Changed();
return true;
}
return false;
}
Contains(complexProperty: TComplexProperty): boolean {
return this.items.Contains(complexProperty);
}
IndexOf(complexProperty: TComplexProperty): number {
return this.items.IndexOf(complexProperty);
}
GetEnumerator(): IEnumerator<TComplexProperty> {
return this.items.GetEnumerator();
}
WriteSetUpdateToXml(writer: EwsServiceXmlWriter, ewsObject: ServiceObject, propertyDefinition: PropertyDefinition): boolean {
if (this.Count === 0) {
writer.WriteStartElement(XmlNamespace.Types, ewsObject.GetDeleteFieldXmlElementName());
propertyDefinition.WriteToXml(writer);
writer.WriteEndElement();
return true;
}
return false;
}
WriteDeleteUpdateToXml(writer: EwsServiceXmlWriter, ewsObject: ServiceObject): boolean {
return false;
}
WriteSetUpdateToJson(service: ExchangeService, ewsObject: ServiceObject, propertyDefinition: PropertyDefinition, updates: List<JsonObject>): boolean {
if (this.Count === 0) {
var jsonObject: JsonObject = new JsonObject();
jsonObject.AddTypeParameter(ewsObject.GetDeleteFieldXmlElementName());
jsonObject.Add("Path", (<IJsonSerializable>propertyDefinition).ToJson(service));
return true;
}
return false;
}
WriteDeleteUpdateToJson(service: ExchangeService, ewsObject: ServiceObject, updates: List<JsonObject>): boolean {
return false;
}
}
class AddressEntityCollection extends ComplexPropertyCollection<AddressEntity>
{
constructor();
constructor(collection: IEnumerable<AddressEntity>);
constructor(collection?: IEnumerable<AddressEntity>) {
if (arguments.length === 0) {
super();
this.constructor_0();
return;
}
super();
this.constructor_1(collection);
}
private constructor_0(): void {
}
private constructor_1(collection: IEnumerable<AddressEntity>): void {
if (collection !== null) {
EwsUtilities.ForEach<AddressEntity>(collection, super.InternalAdd);
}
}
CreateComplexProperty(xmlElementName: string): AddressEntity {
return new AddressEntity();
}
CreateDefaultComplexProperty(): AddressEntity {
return new AddressEntity();
}
GetCollectionItemXmlElementName(complexProperty: AddressEntity): string {
return "Address";
}
}
class ServiceId extends ComplexProperty {
private changeKey: string = null;
private uniqueId: string = null;
get IsValid(): boolean {
return !NString.IsNullOrEmpty(this.uniqueId);
}
set UniqueId(value: string) {
this.uniqueId = value;
}
get UniqueId(): string {
return this.uniqueId;
}
set ChangeKey(value: string) {
this.changeKey = value;
}
get ChangeKey(): string {
return this.changeKey;
}
constructor();
constructor(uniqueId: string);
constructor(uniqueId?: string) {
super();
if (arguments.length === 0) {
this.constructor_0();
return;
}
this.constructor_1(uniqueId);
}
private constructor_0(): void {
}
private constructor_1(uniqueId: string): void {
this.constructor_0();
EwsUtilities.ValidateParam(uniqueId, "uniqueId");
this.uniqueId = uniqueId;
}
ReadAttributesFromXml(reader: EwsServiceXmlReader): void {
this.uniqueId = reader.ReadAttributeValue("Id");
this.changeKey = reader.ReadAttributeValue("ChangeKey");
}
LoadFromJson(jsonProperty: JsonObject, service: ExchangeService): void {
var enumerator: Dictionary_KeyCollection_Enumerator<string, any> = jsonProperty.Keys.GetEnumerator();
try {
while (enumerator.MoveNext()) {
var current: string = enumerator.Current;
var a: string;
if ((a = current) !== null) {
if (!(a === "Id")) {
if (a === "ChangeKey") {
this.changeKey = jsonProperty.ReadAsString(current);
}
}
else {
this.uniqueId = jsonProperty.ReadAsString(current);
}
}
}
}
finally {
(<IDisposable>enumerator).Dispose();
}
}
WriteAttributesToXml(writer: EwsServiceXmlWriter): void {
writer.WriteAttributeValue("Id", this.UniqueId);
writer.WriteAttributeValue("ChangeKey", this.ChangeKey);
}
InternalToJson(service: ExchangeService): any {
var jsonObject: JsonObject = new JsonObject();
jsonObject.AddTypeParameter(this.GetJsonTypeName());
jsonObject.Add("Id", this.UniqueId);
jsonObject.Add("ChangeKey", this.ChangeKey);
return jsonObject;
}
GetXmlElementName(): string {
throw new NotSupportedException();
}
GetJsonTypeName(): string {