/// <summary>
/// add business instance
/// </summary>
/// <param name="type"></param>
public static void AddBusinessInstance(BusinessType type)
{
if (null == instanceCache)
{
instanceCache = new Dictionary <BusinessType, IBusiness>();
}
if (instanceCache.ContainsKey(type) && instanceCache[type] != null)
{
return;
}
try
{
if (type == BusinessType.AgentGateway)
{
instanceCache.Add(BusinessType.AgentGateway, new AgentGatewayBusiness());
}
else if (type == BusinessType.OCX)
{
instanceCache.Add(BusinessType.OCX, new OCXBusiness());
}
}
catch (ArgumentException exc)
{
ErrorMessage = exc.Message;
}
}
// PUT api/BusinessTypeAPI/5
public HttpResponseMessage PutBusinessType(int id, BusinessType businesstype)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (id != businesstype.Id)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
db.Entry(businesstype).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
return(Request.CreateResponse(HttpStatusCode.OK));
}
/// <summary>
/// 创建业务节点
/// </summary>
/// <param name="xElementParent">该业务在父节点</param>
/// <param name="businessType">业务实体</param>
private static ResultInfo CreateBusinessTypeNode(XElement xElementParent, BusinessType businessType)
{
ResultInfo resultInfo = null;
try
{
XElement newElement = new XElement("BusinessType",
new XAttribute("Name", businessType.Name),
new XElement("CommendServices",
new XElement("CommendService",
new XAttribute("Guid", businessType.CommentService[0].Guid),
new XAttribute("Name", businessType.CommentService[0].Name),
new XAttribute("Enable", businessType.CommentService[0].Enable.ToString().ToLower()),
new XAttribute("Description", businessType.CommentService[0].Description),
new XAttribute("LogoUrl", businessType.CommentService[0].LogoUrl)
)));
xElementParent.Element("BusinessTypes").Add(newElement);
resultInfo = ResultInfoFactory <ResultInfo> .Create(true, "BusinessSuccessed", "业务节点 {0} 创建成功", businessType.Name);
}
catch (Exception ex)
{
resultInfo = ResultInfoFactory <ResultInfo> .Create(false, "BusinessException", "业务节点 {0} 创建时异常:\r\t{1}", businessType.Name, ex.Message);
}
return(resultInfo);
}
public void InsertUpdateDelete()
{
BusinessTypeController businessTypeController = new BusinessTypeController();
//create new entity
BusinessType businessType = new BusinessType();
businessType.businessTypeId = Guid.NewGuid();
businessType.name = "Test Name";
businessType.entryDate = DateTime.Now;
businessType.appUserId = Guid.NewGuid();
businessType.modifiedDate = DateTime.Now;
businessType.remark = "Test Remark";
//insert
var result1 = businessTypeController.Post(businessType);
//update
var result2 = businessTypeController.Post(businessType);
//delete
var result3 = businessTypeController.Delete(businessType.businessTypeId);
//assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result2);
Assert.IsNotNull(result3);
Assert.IsTrue(result1 is OkResult);
Assert.IsTrue(result2 is OkResult);
Assert.IsTrue(result3 is OkResult);
}
/// <summary>
/// 新建xml文档
/// </summary>
/// <param name="path">文件保存的路径</param>
/// <param name="businessType">业务实体</param>
private static ResultInfo CreateXmlFile(string path, BusinessType businessType)
{
ResultInfo resultInfo = null;
try
{
XDocument xmlDoc = new XDocument(
new XDeclaration("1.0", "utf-8", "no"),
new XElement("XmlCommendService",
new XElement("BusinessTypes",
new XElement("BusinessType",
new XAttribute("Name", businessType.Name),
new XElement("CommendServices",
new XElement("CommendService",
new XAttribute("Guid", businessType.CommentService[0].Guid),
new XAttribute("Name", businessType.CommentService[0].Name),
new XAttribute("Enable", businessType.CommentService[0].Enable.ToString()),
new XAttribute("Description", businessType.CommentService[0].Description),
new XAttribute("LogoUrl", businessType.CommentService[0].LogoUrl)
))))));
xmlDoc.Save(path);
resultInfo = ResultInfoFactory <ResultInfo> .Create(true, "XDocumentSuccessed", "Xml创建成功");
}
catch (Exception ex)
{
resultInfo = ResultInfoFactory <ResultInfo> .Create(false, "XDocumentException", "Xml创建时异常:\r\t{1}", ex.Message);
}
return(resultInfo);
}
public async Task <Response> Update(int id, [FromForm] BusinessType model)
{
Response _objResponse = new Response();
try
{
if (id != model.BusinessTypeId)
{
_objResponse.Status = "No record found";
_objResponse.Data = null;
}
else
{
model.UpdatedDate = DateTime.Now;
model.BusinessTypeURL = urlreplace(model.Business);
_context.Entry(model).Property(x => x.CreatedDate).IsModified = false;
_context.Entry(model).State = EntityState.Modified;
await _context.SaveChangesAsync();
_objResponse.Status = "Success";
_objResponse.Data = null;
}
}
catch (Exception ex)
{
_objResponse.Data = null;
_objResponse.Status = ex.ToString();
Console.WriteLine("\nMessage ---\n{0}", ex.ToString());
Console.WriteLine("\nStackTrace ---\n{0}", ex.StackTrace);
}
return(_objResponse);
}
public void MapEntityType(BusinessType entityType, string expected)
{
testBusiness.Type = entityType;
var result = businessMap.Map(testBusiness);
Assert.Equal(expected, result.EntityType);
}
/// <summary>
/// User constructor
/// </summary>
/// <param name="userHandle"></param>
/// <param name="entityName"></param>
/// <param name="identityValue"></param>
/// <param name="phone"></param>
/// <param name="email"></param>
/// <param name="streetAddress1"></param>
/// <param name="streetAddress2"></param>
/// <param name="city"></param>
/// <param name="state"></param>
/// <param name="postalCode"></param>
/// <param name="cryptopAddress"></param>
/// <param name="businessType"></param>
/// <param name="businessWebsite"></param>
/// <param name="doingBusinessAs"></param>
/// <param name="naicsCode"></param>
/// <param name="country"></param>
/// <param name="contactAlias"></param>
/// <param name="cryptoAlias"></param>
/// <param name="addressAlias"></param>
/// <param name="type"></param>
/// <param name="deviceFingerprint"></param>
/// <param name="smsOptIn"></param>
public BusinessUser(string userHandle, string entityName = null, string identityValue = null, string phone = null,
string email = null, string streetAddress1 = null, string streetAddress2 = null, string city = null, string state = null, string postalCode = null,
string cryptopAddress = null, BusinessType businessType = null, string businessWebsite = null, string doingBusinessAs = null, int?naicsCode = null,
string country = null, string contactAlias = null, string cryptoAlias = null, string addressAlias = null, string type = null,
string deviceFingerprint = null, bool?smsOptIn = null)
{
UserHandle = userHandle;
EntityName = entityName;
IdentityValue = identityValue;
Phone = phone;
Email = email;
StreetAddress1 = streetAddress1;
StreetAddress2 = streetAddress2;
City = city;
State = state;
PostalCode = postalCode;
CryptoAddress = cryptopAddress;
BusinessType = businessType.Name;
BusinessWebsite = businessWebsite;
DoingBusinessAs = doingBusinessAs;
NaicsCode = naicsCode;
Country = country;
ContactAlias = contactAlias;
CryptoAlias = cryptoAlias;
AddressAlias = addressAlias;
Type = type;
DeviceFingerprint = deviceFingerprint;
SmsOptIn = smsOptIn;
}
public IEnumerable <Business> Search(string postcode, string type, double distance = 10.0, bool ascending = true, int page = 1,
int pageSize = 25)
{
double fixedDistance = FixDistance(distance);
int fixedPage = page < 1 ? 1 : page;
int fixedPageSize = pageSize < 10 ? 10 : pageSize;
DbGeography postcodeLocation = PostcodesService.Lookup(postcode);
BusinessType businessType = _businessTypeStore.FindByName(type);
double distanceInMeters = GeoUtils.MilesToMeters(fixedDistance);
int skip = (fixedPage - 1) * fixedPageSize;
var searchFilter = _context.Businesses.Where(t => t.Location.Distance(postcodeLocation) <= distanceInMeters && t.BusinessTypeId == businessType.Id);
if (ascending)
{
return(searchFilter.OrderBy(f => f.Location.Distance(postcodeLocation)).Skip(skip).Take(fixedPageSize));
}
else
{
return(searchFilter.OrderByDescending(f => f.Location.Distance(postcodeLocation)).Skip(skip).Take(fixedPageSize));
}
}
private static void Program_GetResultEvent(string result, BusinessType btype)
{
if (btype == BusinessType.车牌识别门禁)
{
Console.WriteLine(result);
}
}
public ActionResult EditBusinessType(Guid id)
{
BusinessDomainLogic businessDomainLogic = new BusinessDomainLogic();
BusinessType businessType = businessDomainLogic.GetBusinessType(id);
return(PartialView("SaveBusinessType", businessType));
}
/// <summary>
/// 查询信息
/// </summary>
/// <param name="oid">主键</param>
/// <returns></returns>
public BusinessType Retrieve(Guid oid)
{
BusinessType entity = new BusinessType();
entity.TypeID = oid;
return((BusinessType)entity.Retrieve());
}
public ActionResult Edit(BusinessType businessType)
{
client = new FireSharp.FirebaseClient(config);
SetResponse response = client.Set("BusinessType/" + businessType.BusinessTypeID, businessType);
return(RedirectToAction("Index"));
}
/// <summary>
/// 删除
/// </summary>
/// <param name="oid">主键</param>
/// <returns></returns>
public int Delete(Guid oid)
{
BusinessType entity = new BusinessType();
entity.TypeID = oid;
return(entity.Delete());
}
public async Task <ActionResult <BusinessType> > PostBusinessType(BusinessType businessType)
{
_context.BusinessType.Add(businessType);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetBusinessType", new { id = businessType.id }, businessType));
}
public async Task <bool> Delete(BusinessType BusinessType)
{
if (await ValidateId(BusinessType))
{
}
return(BusinessType.IsValidated);
}
public async Task <IActionResult> PutBusinessType(int id, BusinessType businessType)
{
if (id != businessType.id)
{
return(BadRequest());
}
_context.Entry(businessType).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BusinessTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
[HttpGet("ThongKeTheoBusinessType")] //Thống kê số quán theo từng loại mô hình quán
public IActionResult ThongKeTheoBusinessType()
{
try{
BusinessType businessType = new BusinessType(); //Danh sách loại kinh doanh
var danhsachbusinessType = businessType.getAll();
List <BienThongKeBusinessType> bienThongKeQuans = new List <BienThongKeBusinessType>();
foreach (var item in danhsachbusinessType)
{
BienThongKeBusinessType bienThongKes = new BienThongKeBusinessType();
bienThongKes.BusinessTypeID = item.BusinessTypeID;
bienThongKes.BusinessTypetName = item.BusinessTypeName;
bienThongKeQuans.Add(bienThongKes); // Thêm thông tin loại kinh doanh vào danh sách thống kê
}
Store store = new Store();
var danhsachquanan = store.getAll(0, 0);
foreach (var item in bienThongKeQuans)
{
int dem = 0;
foreach (var itemquan in danhsachquanan)
{
if (itemquan.BusinessTypeID == item.BusinessTypeID)
{
dem++; // Nếu BusinessTypeID trùng biến đếm tăng
}
}
item.SoQuan = dem;
}
return(Ok(bienThongKeQuans));
}
catch
{
return(Ok("Error"));
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] BusinessType businessType)
{
if (id != businessType.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(businessType);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BusinessTypeExists(businessType.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(businessType));
}
public void MapBusinessType(BusinessType entityType, BusinessType businessType)
{
testBusiness.Type = entityType;
var result = businessMap.Map(testBusiness);
Assert.Equal(businessType, result.BusinessType);
}
public ActionResult Create_business(BusinessType info, HttpPostedFileBase Photo)
{
string newname = "";
string extention = Path.GetExtension(Photo.FileName);
newname = DateTime.Now.Ticks.ToString() + extention;
var mypath = Path.Combine(Server.MapPath("~/businessImg"), newname);
Photo.SaveAs(mypath);
if (ModelState.IsValid)
{
info.Photo = newname;
db.BusinessType.Add(info);
if (db.SaveChanges() > 0)
{
TempData["success"] = "success add businesstype";
}
else
{
TempData["error"] = "not add yet";
}
}
else
{
TempData["error"] = "Check Some Errors";
}
return(RedirectToAction("Create_business"));
}
private BusinessType Mapper(IDataReader reader)
{
try {
BusinessType _BusinessType = new BusinessType();
if (reader[ID] != null && reader[ID] != DBNull.Value)
{
_BusinessType.ID = Common.Conversion.ToShort(reader[ID]);
}
if (reader[BUSINESSTYPETITLE] != null && reader[BUSINESSTYPETITLE] != DBNull.Value)
{
_BusinessType.BusinessTypeTitle = Common.Conversion.ToString(reader[BUSINESSTYPETITLE]);
}
if (reader[BUSINESSTYPEDESCRIPTION] != null && reader[BUSINESSTYPEDESCRIPTION] != DBNull.Value)
{
_BusinessType.BusinessTypeDescription = Common.Conversion.ToString(reader[BUSINESSTYPEDESCRIPTION]);
}
if (reader[ISACTIVE] != null && reader[ISACTIVE] != DBNull.Value)
{
_BusinessType.IsActive = Common.Conversion.ToBool(reader[ISACTIVE]);
}
return(_BusinessType);
}
catch (Exception exception) {
throw exception;
}
}
[HttpPost("DeleteByID")] //Xóa dữ liệu loại hình kinh doanh quán ăn
public IActionResult DeleteByID(string id)
{
try{
var identity = HttpContext.User.Identity as ClaimsIdentity; //khai báo biến danh tính của token
IList <Claim> claim = identity.Claims.ToList(); //Danh sách các biến trong identity
string Email = claim[1].Value; //Email của token
User infoUser = new User(); //Khai bao biến thông tin người dùng
if (infoUser.kiemtrathoigianlogin(DateTime.Parse(claim[0].Value)) == true) //kiểm tra thời gian đăng nhập còn không
{
if (infoUser.checkAdmin(Email) == true) //Kiểm tra có phải admin không
{
BusinessType businessType1 = new BusinessType(); //Khai báo biến Model BusinessType
businessType1.Delete(id); //delete data
return(Ok(new[] { "Xóa thành công" }));
}
else
{
return(Ok(new[] { "Bạn Không có quyền" }));
}
}
else
{
return(Ok(new[] { "Bạn cần đăng nhập" }));
}
}
catch {
return(Ok(new[] { "Error" }));
}
}
//Constructor with arguments
public Business(String[] args) : base(args)
{
name = args[9];
type = ((BusinessType)Convert.ToUInt32(args[10]));
yearEstablished = args[11];
activeRecruitment = Convert.ToUInt32(args[12]);
}
public async Task <Response> Insert([FromForm] BusinessType model)
{
Response _objResponse = new Response();
try
{
if (ModelState.IsValid)
{
model.CreatedDate = DateTime.Now;
model.UpdatedDate = DateTime.Now;
model.BusinessTypeURL = urlreplace(model.Business);
_context.Add(model);
await _context.SaveChangesAsync();
_objResponse.Status = "Success";
_objResponse.Data = null;
}
else
{
_objResponse.Status = "Validation Error";
_objResponse.Data = null;
}
}
catch (Exception ex)
{
_objResponse.Data = null;
_objResponse.Status = ex.ToString();
Console.WriteLine("\nMessage ---\n{0}", ex.ToString());
Console.WriteLine("\nStackTrace ---\n{0}", ex.StackTrace);
}
return(_objResponse);
}
/// <summary>
/// 获取业务数据
/// </summary>
/// <param name="messgae"></param>
/// <returns></returns>
public BusinessResult ExecuteBusiness(string cmdkey, string args = "", BusinessType type = BusinessType.Get)
{
try
{
if (_BusinessServer == null)
{
return(null);
}
BusinessMessage msg = new BusinessMessage();
msg.BusinessCommand = cmdkey;
msg.BusiType = type;
msg.BusiPriority = BusinessPriority.Highest;
msg.BusinessParam = args;
BusinessResult bs = DeviceCommBusinessServerHelper.Instanse.ExecuteBusiness(msg);
if (bs == null || !bs.Result)
{
return(null);
}
return(bs);
}
catch (Exception ex)
{
ErrorLog.Error(ex.StackTrace.ToString());
}
return(null);
}
public CallLog_BusinessTypeDTO(BusinessType BusinessType)
{
this.Id = BusinessType.Id;
this.Code = BusinessType.Code;
this.Name = BusinessType.Name;
this.Errors = BusinessType.Errors;
}
[HttpPost("CreateBusinessType")] //Thêm dữ liệu loại hình kinh doanh quán ăn
public IActionResult RegisterBusinessType([FromBody] BusinessType businessType)
{
string err = "";
try{
var identity = HttpContext.User.Identity as ClaimsIdentity; //khai báo biến danh tính của token
IList <Claim> claim = identity.Claims.ToList(); //Danh sách các biến trong identity
string Email = claim[1].Value; //Email của token
User infoUser = new User(); //Khai bao biến thông tin người dùng
if (infoUser.kiemtrathoigianlogin(DateTime.Parse(claim[0].Value)) == true) //kiểm tra thời gian đăng nhập còn không
{
if (infoUser.checkAdmin(Email) == true) //Kiểm tra có phải admin không
{
BusinessType businessType1 = new BusinessType(); //Khai báo biến Model BusinessType
businessType1.AddToFireBase(businessType); //Thêm mới một data
err = "Đăng ký thành công";
}
else
{
err = "Bạn Không có quyền";
}
}
else
{
return(Ok(new[] { "Bạn cần đăng nhập" }));
}
}
catch {
err = "Error";
}
return(Ok(new[] { err }));
}
/// <summary>
/// ���캯��
/// </summary>
/// <param name="id">�����û���¼��</param>
public Company(int id)
: base()
{
this.Id = id;
this.busiType = BusinessType.None;
this.turnover = IntRange.None;
this.employee = IntRange.None;
}
public static BusinessTypeModel ToBusinessTypeModel(BusinessType businessType)
{
return(new BusinessTypeModel
{
Id = businessType.Id,
Name = businessType.Name
});
}
public ActionResult DeleteConfirmed(int id)
{
BusinessType businessType = db.BusinessTypes.Find(id);
db.BusinessTypes.Remove(businessType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static Business CreateBusiness(string name, BusinessType type, string registrationNumber,
string additionalRegistrationNumber)
{
if (type == BusinessType.Other)
{
throw new InvalidOperationException("Use CreateOtherBusiness factory method to create a business of type 'Other'");
}
return new Business(name, type, registrationNumber, additionalRegistrationNumber, otherDescription: null);
}
public static ProducerBusiness CreateProducerBusiness(string name, BusinessType type, string registrationNumber,
string otherDescription)
{
if (type == BusinessType.Other)
{
Guard.ArgumentNotNullOrEmpty(() => otherDescription, otherDescription);
}
return new ProducerBusiness(name, type, GetRegistrationNumber(type, registrationNumber), null, otherDescription);
}
protected Business(string name, BusinessType type, string registrationNumber, string additionalRegistrationNumber, string otherDescription)
{
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotNullOrEmpty(() => registrationNumber, registrationNumber);
Name = name;
Type = type;
RegistrationNumber = registrationNumber;
AdditionalRegistrationNumber = additionalRegistrationNumber;
OtherDescription = otherDescription;
}
public void Update(string name, BusinessType type, string otherDescription = null)
{
Guard.ArgumentNotNullOrEmpty(() => name, name);
Guard.ArgumentNotDefaultValue(() => type, type);
if (type == BusinessType.Other)
{
Guard.ArgumentNotNullOrEmpty(() => otherDescription, otherDescription);
}
Name = name;
Type = type;
OtherDescription = otherDescription;
}
private static string GetRegistrationNumber(BusinessType type, string registrationNumber)
{
if (type == BusinessType.LimitedCompany)
{
if (string.IsNullOrWhiteSpace(registrationNumber))
{
throw new InvalidOperationException("Tried to create a producer address for a limited company with an empty string.");
}
return registrationNumber;
}
return RegistrationNumberWhenEmpty;
}
public Facility(string businessName, BusinessType businessType,
string registrationNumber,
Address address, Contact contact, bool isActualSiteOfTreatment)
{
Guard.ArgumentNotNullOrEmpty(() => businessName, businessName);
Guard.ArgumentNotDefaultValue(() => businessType, businessType);
Guard.ArgumentNotNull(() => address, address);
Guard.ArgumentNotNull(() => contact, contact);
Name = businessName;
Type = businessType;
RegistrationNumber = registrationNumber;
Address = address;
Contact = contact;
IsActualSiteOfTreatment = isActualSiteOfTreatment;
}
public void MapBusinessType(BusinessType entityType, BusinessType businessType)
{
testBusiness.Type = entityType;
var result = businessMap.Map(testBusiness);
Assert.Equal(businessType, result.BusinessType);
}
/// <summary>
/// 构造下发数据体
/// </summary>
/// <param name="dataBuffer">用户数据</param>
/// <param name="terminalNum">终端号</param>
/// <param name="businessType">业务类型</param>
/// <param name="dataType">数据类型</param>
/// <returns></returns>
public byte[] BuildSubmitData(byte[] dataBuffer, string terminalNum, BusinessType businessType, DataType dataType)
{
//下发监控请求
YaXunSubmitData submit = new YaXunSubmitData();
submit.areaNum = 0x7f38;
//用户管理
submit.businessType = businessType;
submit.dataType = dataType;
submit.destPhone = terminalNum;
submit.sourcePhone = terminalNum;
submit.data = dataBuffer;
byte[] destBuffer = new byte[submit.GetLength()];
submit.WriteBuffer(destBuffer);
//GPRS信息帧数据
GPRSFrame gprsFrame = new GPRSFrame();
gprsFrame.Data = destBuffer;
gprsFrame.CmdType = GPRSCmdType.GPRSTransferData;
destBuffer = new byte[gprsFrame.GetLength()];
gprsFrame.WriteBuffer(destBuffer);
//转义之后发出
return YaXunDataSpliter.BufferToESC(destBuffer);
}
/// <summary>
/// ���캯��
/// </summary>
public Company()
: base()
{
this.busiType = BusinessType.None;
}
private ProducerBusiness(string name, BusinessType type, string registrationNumber,
string additionalRegistrationNumber, string otherDescription)
: base(name, type, registrationNumber, additionalRegistrationNumber, otherDescription)
{
}
public static Order SetBusinessType(this Order order, BusinessType business)
{
order.GetDictionary()[OrderTagType.Business] = business;
return order;
}
/// <summary>
/// 将数据读入结构体:数据类型长度至少为7
/// </summary>
/// <param name="receivedBuffer">从下行接收到的byte数组</param>
public void ReadBuffer(byte[] receivedBuffer)
{
//如果是无效数据则丢弃
if (receivedBuffer.Length < 7)
{
isValidData = false;
return;
}
//获取到数据段
byte[] dataBuffer = receivedBuffer;
//取出区域号
byte[] destBuffer = new byte[2];
Array.Copy(dataBuffer, 0, destBuffer, 0, 2);
short netNum = BitConverter.ToInt16(destBuffer, 0);
areaNum = (ushort)IPAddress.NetworkToHostOrder(netNum);
//版本号
destBuffer = new byte[2];
Array.Copy(dataBuffer, 2, destBuffer, 0, 2);
netNum = BitConverter.ToInt16(destBuffer, 0);
versionNum = (ushort)IPAddress.NetworkToHostOrder(netNum);
//业务类型
businessType = (BusinessType)dataBuffer[4];
//数据类型
dataType = (DataType)dataBuffer[5];
//手机号码
//destBuffer = new byte[15];
//Array.Copy(dataBuffer, 6, destBuffer, 0, 15);
//telephone = Encoding.ASCII.GetString(destBuffer);
//校验位
checkCode = dataBuffer[receivedBuffer.Length - 1];
//校验，先认为是正确数据
//用户数据
//用户数据长度
int dataLen = dataBuffer.Length - 7;
data = new byte[dataLen];
Array.Copy(dataBuffer, 6, data, 0, dataLen);
isValidData = true;
}
