schedulesmsmanager.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Base.Sipc;
    using Imps.Client;
    using Imps.Client.Base;
    using Imps.Client.Resource;
    using Imps.Client.Utils;
    using Imps.Common;
    using Imps.Utils;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using System.Runtime.CompilerServices;
    using System.Xml;

    public class ScheduleSmsManager
    {
        private Imps.Client.Core.ScheduleSmsList _scheduleSmsList;
        private Imps.Client.Core.User _user;

        public event EventHandler<ScheduleSmsesDeletedEventArgs> ScheduleSmsesDeleted;

        public event EventHandler<ScheduleSmsesUpdateEventArgs> ScheduleSmsesUpdated;

        public ScheduleSmsManager(Imps.Client.Core.User user)
        {
            this._user = user;
            this._scheduleSmsList = new Imps.Client.Core.ScheduleSmsList(this._user);
        }

        public bool AsyncDeleteScheduleSms(string[] ids, AsyncBizOperation op)
        {
            if (ids.Length == 0)
            {
                return false;
            }
            SipRequest req = this._user.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("SSDeleteScheduleSms"));
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("schedule-sms-list");
                foreach (string text in ids)
                {
                    writer.WriteStartElement("schedule-sms");
                    writer.WriteAttributeString("id", text);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncDeleteScheduleSms);
            this._user.SendSipMessage(req);
            return true;
        }

        public bool AsyncGetScheduleSms(string[] ids, AsyncBizOperation op)
        {
            if ((this._scheduleSmsList.PageSize > 0) && (ids.Length > this._scheduleSmsList.PageSize))
            {
                if (op != null)
                {
                    op.FireSuccessedInUiThread(EventArgs.Empty);
                }
                return false;
            }
            SipRequest req = this._user.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("SSGetScheduleSms"));
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("schedule-sms-list");
                foreach (string text in ids)
                {
                    writer.WriteStartElement("schedule-sms");
                    writer.WriteAttributeString("id", text);
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncGetScheduleSms);
            this._user.SendSipMessage(req);
            return true;
        }

        public bool AsyncGetScheduleSmsBatch(AsyncBizOperation op)
        {
            EventHandler<ImpsErrorEventArgs> handler = null;
            EventHandler handler2 = null;
            try
            {
                if (this._scheduleSmsList.ScheduleSmses.Count == 0)
                {
                    if (op != null)
                    {
                        op.FireSuccessedInUiThread(EventArgs.Empty);
                    }
                    return true;
                }
                ArrayList list = new ArrayList();
                lock (this._scheduleSmsList.ScheduleSmses.SyncRoot)
                {
                    using (IEnumerator<ScheduleSms> enumerator = this._scheduleSmsList.ScheduleSmses.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            ScheduleSms sms = enumerator.get_Current();
                            if ((sms.Version != sms.NewVersion) && !sms.BeenGetInfo)
                            {
                                list.Add(sms.Id);
                                sms.BeenGetInfo = true;
                            }
                            if (list.Count >= this._scheduleSmsList.PageSize)
                            {
                                goto Label_00EE;
                            }
                        }
                    }
                }
            Label_00EE:
                if (list.Count == 0)
                {
                    if (op != null)
                    {
                        op.FireSuccessedInUiThread(EventArgs.Empty);
                    }
                    return true;
                }
                AsyncBizOperation operation = new AsyncBizOperation();
                if (handler == null)
                {
                    <>c__DisplayClass14 class2;
                    handler = new EventHandler<ImpsErrorEventArgs>(class2, (IntPtr) this.<AsyncGetScheduleSmsBatch>b__10);
                }
                operation.ImpsError += handler;
                if (handler2 == null)
                {
                    handler2 = delegate {
                        if (this._user.Status == UserAccountStatus.Logon)
                        {
                            this.AsyncGetScheduleSmsBatch(op);
                        }
                    };
                }
                operation.Successed += handler2;
                this.AsyncGetScheduleSms((string[]) list.ToArray(typeof(string)), operation);
                return true;
            }
            catch (Exception exception)
            {
                ClientLogger.WriteException(exception);
                return false;
            }
        }

        public bool AsyncGetScheduleSmsList(string version, int? pageNo, AsyncBizOperation op)
        {
            SipRequest req = this._user.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("SSGetScheduleSmsList"));
            req.Context = op;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("schedule-sms-list");
                writer.WriteAttributeString("version", version);
                if (pageNo.get_HasValue())
                {
                    writer.WriteAttributeString("page-no", pageNo.ToString());
                }
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncGetScheduleSmsList);
            this._user.SendSipMessage(req);
            return true;
        }

        public bool AsyncSetScheduleSms(DateTime sendTime, string message, IicUri[] uris, AsyncBizOperation op)
        {
            if (uris.Length == 0)
            {
                return false;
            }
            if (message.Length == 0)
            {
                return false;
            }
            SipRequest req = this._user.CreateSipRequest("S");
            req.Message.AddHeader(new SipcEventHeader("SSSetScheduleSms"));
            req.Context = op;
            ScheduleSms sms = new ScheduleSms(this._scheduleSmsList, sendTime, uris, message);
            op.ContextForBiz = sms;
            StringWriter tw = new StringWriter();
            XmlHelper.CreateXmlWriterForSipRequest(tw, null, delegate (XmlWriter writer, object context) {
                writer.WriteStartElement("schedule-sms");
                writer.WriteAttributeString("send-time", sendTime.ToUniversalTime().ToString("yyyy-MM-dd HH:mm:ss"));
                writer.WriteStartElement("message");
                writer.WriteString(message);
                writer.WriteEndElement();
                writer.WriteStartElement("receivers");
                foreach (IicUri uri in uris)
                {
                    writer.WriteStartElement("receiver");
                    writer.WriteAttributeString("uri", uri.ToString());
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
                writer.WriteEndElement();
            });
            req.Message.Body = tw.ToString();
            tw.Dispose();
            ErrorHelper.HandleSendRequestErrorAndTimeout(req);
            req.FinalResponseReceived += new EventHandler<SipResponseReceivedEventArgs>(this, (IntPtr) this.finalResponseReceived_AsyncSetScheduleSms);
            this._user.SendSipMessage(req);
            return true;
        }

        public void Clear()
        {
            this._scheduleSmsList.Clear();
        }

        private void finalResponseReceived_AsyncDeleteScheduleSms(object sender, SipResponseReceivedEventArgs e)
        {
            SipResponse sipMsg = e.Response;
            AsyncBizOperation op = (AsyncBizOperation) sipMsg.Request.Context;
            if (!sipMsg.IsOK)
            {
                LogHelper.LogReceivedSipMessage(sipMsg);
                switch (sipMsg.Message.StatusCode)
                {
                    case 0x199:
                        this._user.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.SchduleSms.DeleteSms.Err_409), op);
                        return;

                    case 500:
                        this._user.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.SchduleSms.DeleteSms.Err_500), op);
                        return;

                    case 400:
                        this._user.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.SchduleSms.DeleteSms.Err_400), op);
                        return;

                    case 0x194:
                        this._user.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.SchduleSms.DeleteSms.Err_404), op);
                        return;
                }
                this._user.FireImpsErrorInUiThread(new ImpsErrorEventArgs(StringTable.SchduleSms.DeleteSms.Err_Default), op);
            }
            else
            {
                XmlDocument document = new XmlDocument();
                document.LoadXml(sipMsg.Message.Body);
                XmlNode node = document.DocumentElement.SelectSingleNode("schedule-sms-list");
                if (node != null)
                {
                    string text = XmlHelper.ReadXmlAttributeString(node, "version");
                    this._scheduleSmsList.Version = text;
                    XmlNodeList list = node.SelectNodes("schedule-sms");
                    if ((list != null) && (list.Count != 0))
                    {
                        ArrayList list2 = new ArrayList();
                        foreach (XmlNode node2 in list)