sgip.cs

SMGP协议对象

		}

		public override string ToString()
		{
			return string.Format("{0}{1}{2}", Part1, Part2, Part3);
		}

		/*
		   public override bool Equals(object obj)
		   {
			   SequenceNumber r = obj as SequenceNumber;
			   if (r != null)
			   {
				   return (this._part1 == r._part1) && (this._part2 == r._part2) && (this._part3 == r._part3);
			   }
			   return false;
		   }

		   public static bool operator ==(SequenceNumber x, SequenceNumber y)
		   {
			   return (x._part1 == y._part1) && (x._part2 == y._part2) && (x._part3 == y._part3);
		   }

		   public static bool operator !=(SequenceNumber x, SequenceNumber y)
		   {
			   return !(x == y);
		   }
		 */

		/// <summary>
		/// 转换成byte[]类型，以便发送到socket
		/// </summary>
		/// <returns></returns>
		public byte[] GetBytes()
		{
			byte[] result = new byte[12];
			Buffer.BlockCopy(BitConverter.GetBytes(_part1), 0, result, 0, 4);
			Buffer.BlockCopy(BitConverter.GetBytes(_part2), 0, result, 4, 4);
			Buffer.BlockCopy(BitConverter.GetBytes(_part3), 0, result, 8, 4);
			return result;
		}

		/// <summary>
		/// 从一个内存块中读取数据
		/// </summary>
		/// <param name="buffer"></param>
		/// <param name="startIndex"></param>
		internal void ReadFromBytes(byte[] buffer, int startIndex)
		{
			_part1 = BitConverter.ToUInt32(buffer, startIndex);
			_part2 = BitConverter.ToUInt32(buffer, startIndex + 4);
			_part3 = BitConverter.ToUInt32(buffer, startIndex + 8);
		}

		/// <summary>
		/// 从一个byte[]数组中读取序列号对象
		/// </summary>
		/// <param name="buffer"></param>
		/// <param name="startIndex"></param>
		/// <returns></returns>
		public static SequenceNumber ToSequenceNumber(byte[] buffer, int startIndex)
		{
			SequenceNumber sn = new SequenceNumber();
			sn.ReadFromBytes(buffer, startIndex);
			return sn;
		}

		/// <summary>
		/// 生成一个序列号对象
		/// </summary>
		/// <returns></returns>
		public static SequenceNumber CreateSequenceNumber()
		{
			SequenceNumber sn = new SequenceNumber();
			sn.Part1 = 13023;//apiHelper.SP.NodeID;
			sn.Part2 = Convert.ToUInt32(DateTime.Now.ToString("MMddHHmmff"));
			sn.Part3 = _Sequence++;
			return sn;
		}
	}

	public class Bind: Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_BIND;
		}

		private byte _loginType; //1
		private string _loginName = ""; //16;
		private string _loginPassword = ""; //16
		private byte[] _reserved = new byte[8]; //8

		

		/// <summary>
		/// 1：SP向SMG建立的连接，用于发送命令
		//2：SMG向SP建立的连接，用于发送命令
		//3：SMG之间建立的连接，用于转发命令
		//4：SMG向GNS建立的连接，用于路由表的检索和维护
		//5：GNS向SMG建立的连接，用于路由表的更新
		//6：主备GNS之间建立的连接，用于主备路由表的一致性
		//11：SP与SMG以及SMG之间建立的测试连接，用于跟踪测试
		//其它：保留
		/// </summary>
		public byte LoginType
		{
			get { return _loginType; }
			set { _loginType = value; }
		}

		/// <summary>
		/// 服务器分配的登录名，最长为16
		/// </summary>
		public string LoginName
		{
			get { return _loginName; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_loginName = value;
			}
		}

		/// <summary>
		/// 密码
		/// </summary>
		public string LoginPassword
		{
			get { return _loginPassword; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_loginPassword = value;
			}
		}

		/// <summary>
		/// 保留，最多8个字节
		/// </summary>
		public byte[] Reserved
		{
			get { return _reserved; }
			set
			{
				apiHelper.CheckMaxBytes(value, 8);
				_reserved = value;
			}
		}

		public override int GetLength()
		{
			return 41;
		}

		public override byte[] GetBytes()
		{
			byte[] result = new byte[this.GetLength()];
			int nIndex = 0;
			result[nIndex++] = _loginType;
			Encoding.Default.GetBytes(_loginName).CopyTo(result, nIndex);    //_loginName
			nIndex += 16;
			Encoding.Default.GetBytes(_loginPassword).CopyTo(result, nIndex); //_loginPassword
			nIndex += 16;
			_reserved.CopyTo(result, nIndex); //_reserved            
			return result;
		}

		internal override void ReadFromBytes(byte[] buffer, int startIndex)
		{
			int nIndex = startIndex;
			_loginType = buffer[nIndex++];
			_loginName = apiHelper.GetASCIIString(buffer, nIndex, 16);           
			nIndex += 16;
			_loginPassword = apiHelper.GetASCIIString(buffer, nIndex, 16);
			nIndex += 16;
			Buffer.BlockCopy(buffer, nIndex, _reserved, 0, 8);
		}

		public Bind()
		{
		}

		public Bind(byte bLoginType, string strLoginName, string strLoginPwd)
		{
			LoginType = bLoginType;
			LoginName = strLoginName;
			LoginPassword = strLoginPwd;
		}
	}

	public class UserNumber : ArrayList
	{
		public void Add(string strPhoneNumber)
		{
			base.Add(apiHelper.Prefix86ForMobilbeNumber(strPhoneNumber));
		}

		public override string ToString()
		{
			StringBuilder sbResult = new StringBuilder();
			for (int i = 0; i < this.Count; ++i)
			{
				sbResult.Append(this[i] + ",");
			}
			return sbResult.ToString().Substring(0, sbResult.Length - 1);
		}
	}

	public class Bind_Resp : ResponseBody
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_BIND_RESP;
		}
	};

	public class Unbind: Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_UNBIND;
		}
	}

	public class Unbind_Resp : Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_UNBIND_RESP;
		}
	}

	public class Submit: Body
	{
		public override uint GetCommandID()
		{
			return Command.SGIP_SUBMIT;
		}

		#region private members
		private string _spNumber = ""; //21, SP的接入号码(=特服号＝服务代码)
		private string _chargeNumber = ""; //21, 付费号码，手机号码前加"86"国别标志；当且仅当群发且对用户收费时为空；如果为空，则该条短消息产生的费用由UserNumber代表的用户支付；如果为全零字符串"000000000000000000000"，表示该条短消息产生的费用由SP支付。
		private byte _userCount; //1, 接收短消息的手机数量，取值范围1至100
		private UserNumber _userNumber = new UserNumber(); //21 * _userCount, 接收该短消息的手机号，该字段重复UserCount指定的次数，手机号码前加"86"国别标志
		private string _corpID = ""; //5, 企业代码，取值范围0-99999
		private string _serviceType = ""; //10, 业务代码，由SP定义
		private byte _feeType;      //1, 计费类型
		private string _feeValue = "";   //6, 取值范围0-99999，该条短消息的收费值，单位为分，由SP定义,对于包月制收费的用户，该值为月租费的值
		private string _givenValue = ""; //6, 取值范围0-99999，赠送用户的话费，单位为分，由SP定义，特指由SP向用户发送广告时的赠送话费
		private byte _agentFlag;    //1, 代收费标志，0：应收；1：实收
		private byte _morelatetoMTFlag;  //1, 引起MT消息的原因:0-MO点播引起的第一条MT消息；1-MO点播引起的非第一条MT消息；2-非MO点播引起的MT消息；3-系统反馈引起的MT消息。
		private byte _priority;         //1, 优先级0-9从低到高，默认为0
		private string _expireTime = "";     //16, 短消息寿命的终止时间，如果为空，表示使用短消息中心的缺省值。时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
		private string _scheduleTime = "";   //16, 短消息定时发送的时间，如果为空，表示立刻发送该短消息。时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
		private byte _reportFlag;     //1, 状态报告标记0-该条消息只有最后出错时要返回状态报告1-该条消息无论最后是否成功都要返回状态报告2-该条消息不需要返回状态报告3-该条消息仅携带包月计费信息，不下发给用户，要返回状态报告其它-保留缺省设置为0
		private byte _TP_pid;         //1, GSM协议类型。详细解释请参考GSM03.40中的9.2.3.9
		private byte _TP_udhi;        //1, GSM协议类型。详细解释请参考GSM03.40中的9.2.3.23,仅使用1位，右对齐
		private byte _messageCoding;  //1, 短消息的编码格式。0：纯ASCII字符串 3：写卡操作 4：二进制编码 8：UCS2编码 15: GBK编码 其它参见GSM3.38第4节：SMS Data Coding Scheme
		private byte _messageType;    //1, 信息类型：0-短消息信息,其它：待定
		private uint _messageLength = 140;   //4, 默认为140,短消息的长度
		private string _messageContent = ""; //_messageLength, 短消息的内容
		private byte[] _reserved = new byte[8];      //8, 保留，扩展用
		#endregion

		#region public propertys

		/// <summary>
		/// SP的接入号码(=特服号＝服务代码)
		/// </summary>
		public string SPNumber
		{
			get { return _spNumber;}
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_spNumber = value;
			}
		}

		/// <summary>
		/// 付费号码，手机号码前加"86"国别标志；当且仅当群发且对用户收费时为空；如果为空，则该条短消息产生的费用由UserNumber代表的用户支付；如果为全零字符串"000000000000000000000"，表示该条短消息产生的费用由SP支付。
		/// </summary>
		public string ChargeNumber
		{
			get { return _chargeNumber;}
			set
			{
				apiHelper.CheckMaxBytes(value, 21);
				_chargeNumber = apiHelper.Prefix86ForMobilbeNumber(value);
			}
		}

		/// <summary>
		/// 接收短消息的手机数量，取值范围1至100
		/// </summary>
		public byte UserCount
		{
			get
			{
				return _userCount;
			}
			set
			{
				_userCount = value;
			}
		}

		/// <summary>
		/// 接收该短消息的手机号，该字段重复UserCount指定的次数，手机号码前加"86"国别标志(apiHelper.Prefix86ForMobilbeNumber(value))
		/// </summary>
		public UserNumber UserNumber
		{
			get { return _userNumber; }
			set { _userNumber = value; }
		}

		/// <summary>
		/// 企业代码，取值范围0-99999
		/// </summary>
		public string CorpID
		{
			get { return _corpID; }
			set
			{
				apiHelper.CheckMaxBytes(value, 5);
				_corpID = value;
			}
		}

		/// <summary>
		/// 业务代码，由SP定义
		/// </summary>
		public string ServiceType
		{
			get { return _serviceType; }
			set
			{
				apiHelper.CheckMaxBytes(value, 10);
				_serviceType = value;
			}
		}

		/// <summary>
		/// 计费类型
		/// </summary>
		public byte FeeType
		{
			get 
			{ 
				return _feeType; 
			}
			set
			{
				_feeType = value;
			}
		}

		/// <summary>
		/// 取值范围0-99999，该条短消息的收费值，单位为分，由SP定义,对于包月制收费的用户，该值为月租费的值
		/// </summary>
		public string FeeValue
		{
			get { return _feeValue; }
			set
			{
				apiHelper.CheckMaxBytes(value, 6);
				_feeValue = value;
			}
		}

		/// <summary>
		/// 取值范围0-99999，赠送用户的话费，单位为分，由SP定义，特指由SP向用户发送广告时的赠送话费
		/// </summary>
		public string GivenValue
		{
			get { return _givenValue; }
			set
			{
				apiHelper.CheckMaxBytes(value, 6);
				_givenValue = value;
			}
		}

		/// <summary>
		/// 代收费标志，0：应收；1：实收
		/// </summary>
		public byte AgentFlag
		{
			get
			{
				return _agentFlag;
			}
			set
			{
				_agentFlag = value;
			}
		}

		/// <summary>
		/// 引起MT消息的原因:0-MO点播引起的第一条MT消息；1-MO点播引起的非第一条MT消息；2-非MO点播引起的MT消息；3-系统反馈引起的MT消息。
		/// </summary>
		public byte MorelatetoMTFlag
		{
			get
			{
				return _morelatetoMTFlag;
			}
			set
			{
				_morelatetoMTFlag = value;
			}
		}

		/// <summary>
		/// 优先级0-9从低到高，默认为0
		/// </summary>
		public byte Priority
		{
			get
			{
				return _priority;
			}
			set
			{
				_priority = value;
			}
		}

		/// <summary>
		/// 短消息寿命的终止时间，如果为空，表示使用短消息中心的缺省值。时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
		/// </summary>
		public string ExpireTime
		{
			get { return _expireTime; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_expireTime = value;
			}
		}

		/// <summary>
		/// 短消息定时发送的时间，如果为空，表示立刻发送该短消息。时间内容为16个字符，格式为"yymmddhhmmsstnnp" ，其中"tnnp"取固定值"032+"，即默认系统为北京时间
		/// </summary>
		public string ScheduleTime
		{
			get { return _scheduleTime; }
			set
			{
				apiHelper.CheckMaxBytes(value, 16);
				_scheduleTime = value;
			}
		}

		/// <summary>