public void Base64BytesEncodeTest(int count)
{
var inputBytes = new byte[count];
var r = new Random(count);
r.NextBytes(inputBytes);
var expectedBase64String = Convert.ToBase64String(inputBytes);
var expectedBase64Buffer = expectedBase64String.ToCharArray().Select(v => (byte)v).ToArray();
// transform block
var inputOffset = r.Next(0, 100);
var inputBuffer = new byte[inputOffset + inputBytes.Length + inputOffset];
Buffer.BlockCopy(inputBytes, 0, inputBuffer, inputOffset, inputBytes.Length);
var outputOffset = r.Next(0, 100);
var outputBuffer = new byte[outputOffset + expectedBase64Buffer.Length];
var written = Base64Convert.Encode(new ArraySegment <byte>(inputBuffer, inputOffset, inputBytes.Length), new ArraySegment <byte>(outputBuffer, outputOffset, outputBuffer.Length - outputOffset), out var inputUsed, out var outputUsed);
var actualOutput = outputBuffer.Skip(outputOffset).ToArray();
Assert.Equal(expectedBase64Buffer.Length, Base64Convert.GetBase64OutputLength(inputBytes.Length, true));
Assert.Equal(expectedBase64Buffer.Length, written);
Assert.Equal(expectedBase64Buffer.Length, outputUsed);
Assert.Equal(inputBytes.Length, inputUsed);
Assert.Equal(expectedBase64Buffer, actualOutput);
}
public void BufferToBase64ConvertTest(int count)
{
var expectedBuffer = new byte[count];
var r = new Random(count);
r.NextBytes(expectedBuffer);
var expectedBase64String = Convert.ToBase64String(expectedBuffer);
var expectedBase64Chars = expectedBase64String.ToCharArray();
var inputOffset = r.Next(0, 100);
var inputBuffer = new byte[inputOffset + expectedBuffer.Length + inputOffset];
Buffer.BlockCopy(expectedBuffer, 0, inputBuffer, inputOffset, expectedBuffer.Length);
// buffer -> base64 string
var base64String = Base64Convert.ToString(inputBuffer, inputOffset, expectedBuffer.Length);
Assert.Equal(expectedBase64String, base64String);
// buffer -> base64 buffer
var base64Chars = Base64Convert.ToCharArray(inputBuffer, inputOffset, expectedBuffer.Length);
Assert.Equal(expectedBase64Chars, base64Chars);
// buffer -> base64 buffer (copy)
base64Chars = new char[expectedBase64Chars.Length];
Base64Convert.Encode(new ArraySegment <byte>(inputBuffer, inputOffset, expectedBuffer.Length), new ArraySegment <char>(base64Chars));
Assert.Equal(expectedBase64Chars, base64Chars);
}
public void Base64ToBufferConvertTest(int count)
{
var expectedBuffer = new byte[count];
var r = new Random(count);
r.NextBytes(expectedBuffer);
var expectedBase64String = Convert.ToBase64String(expectedBuffer);
var expectedBase64Chars = expectedBase64String.ToCharArray();
var inputOffset = r.Next(0, 100);
var inputBuffer = new char[inputOffset + expectedBase64Chars.Length + inputOffset];
expectedBase64Chars.CopyTo(inputBuffer, inputOffset);
var inputString = new string('a', inputOffset) + expectedBase64String + new string('a', inputOffset);
// base64 string -> buffer
var outputBuffer = Base64Convert.ToBytes(inputString, inputOffset, expectedBase64String.Length);
Assert.Equal(expectedBuffer, outputBuffer);
// base64 buffer -> buffer
outputBuffer = Base64Convert.ToBytes(inputBuffer, inputOffset, expectedBase64Chars.Length);
Assert.Equal(expectedBuffer, outputBuffer);
// base64 buffer -> buffer (copy)
outputBuffer = new byte[expectedBuffer.Length];
Base64Convert.Decode(new ArraySegment <char>(inputBuffer, inputOffset, expectedBase64Chars.Length), new ArraySegment <byte>(outputBuffer));
Assert.Equal(expectedBuffer, outputBuffer);
// base64 buffer -> buffer (copy)
outputBuffer = new byte[expectedBuffer.Length];
Base64Convert.Decode(inputString, inputOffset, expectedBase64Chars.Length, new ArraySegment <byte>(outputBuffer));
Assert.Equal(expectedBuffer, outputBuffer);
}
public void ProcessLoggerMessage(SpoolerMessage message)
{
var str1 = Base64Convert.Base64Decode(message.Message);
if (message.Type == MessageType.LoggingMessage)
{
lock (general_log)
{
general_log.Enqueue(message.SerialNumber.ToString() + "::" + str1);
log_updated = true;
}
}
else
{
if (message.Type != MessageType.FullLoggingData)
{
return;
}
string[] strArray = str1.Split('\n');
lock (general_log)
{
general_log.Clear();
foreach (var str2 in strArray)
{
general_log.Enqueue(message.SerialNumber.ToString() + "::" + str2);
}
log_updated = true;
}
}
}
public void ToByteStringTest()
{
var baseNString = "eg==";
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNString);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayPartialTest()
{
var baseNCharBytes = "99eg==99".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNCharBytes, 2, baseNCharBytes.Length - 4);
Assert.Equal(expected, actual);
}
public void ToStringTest()
{
var expected = "eg==";
var data = new byte[] { 122 };
var actual = Base64Convert.ToString(data);
Assert.Equal(expected, actual);
}
public void ToBytesByteArrayTest()
{
var baseNCharBytes = "eg==".ToCharArray().Select(ch => (byte)ch).ToArray();
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNCharBytes);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayPartialTest()
{
var baseNChars = "99eg==99".ToCharArray();
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNChars, 2, baseNChars.Length - 4);
Assert.Equal(expected, actual);
}
public void ToBytesCharArrayTest()
{
var baseNChars = "eg==".ToCharArray();
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNChars);
Assert.Equal(expected, actual);
}
public void ToCharArrayPartialTest()
{
var expected = "eg==".ToCharArray();
var data = new byte[] { 255, 122, 255 };
var actual = Base64Convert.ToCharArray(data, 1, 1);
Assert.Equal(expected, actual);
}
public void ToCharArrayTest()
{
var expected = "eg==".ToCharArray();
var data = new byte[] { 122 };
var actual = Base64Convert.ToCharArray(data);
Assert.Equal(expected, actual);
}
public void ToStringPartialTest()
{
var expected = "eg==";
var data = new byte[] { 255, 122, 255 };
var actual = Base64Convert.ToString(data, 1, 1);
Assert.Equal(expected, actual);
}
public void ToBytesStringPartialTest()
{
var baseNString = "99eg==99";
var expected = new byte[] { 122 };
var actual = Base64Convert.ToBytes(baseNString, 2, baseNString.Length - 4);
Assert.Equal(expected, actual);
}
public void DataProcessFactoryBase64Test()
{
string txt = "x";
var b = new Base64Convert();
var bb = StringByteConver.ToByte(txt);
var code = b.Process(bb);
var code2 = b.DeProcess(code);
var txt1 = StringByteConver.ToString(bb);
var txt2 = StringByteConver.ToString(code2);
Assert.AreEqual(txt1, txt2);
}
public void Base64ConvertTest()
{
var testTest = "hello";
var bs = System.Text.Encoding.Default.GetBytes(testTest);
var stream = new MemoryStream(bs);
var actual = Base64Convert.ToBase64(stream);
var expected = Base64Convert.FrmBase64(actual);
var test2 = System.Text.Encoding.Default.GetString(expected.ToArray());
Assert.AreEqual(testTest, test2);
}
public void Decode_GivenUrlSafeFlag_ReturnsPlainText()
{
var encoded = Encoding.UTF8.GetBytes("ocu7BkU2bu1mq-yB2dL_4A");
var bytes = Base64Convert.Decode(encoded);
bytes.Should().BeEquivalentTo(new byte[]
{
161, 203, 187, 6,
69, 54, 110, 237,
102, 171, 236, 129,
217, 210, 255, 224
});
}
public void Encode_GivenUrlSafeFlag_ReturnsUrlSafeBase64()
{
var bytes = new byte[]
{
161, 203, 187, 6,
69, 54, 110, 237,
102, 171, 236, 129,
217, 210, 255, 224
};
var encoded = Base64Convert.Encode(bytes, true);
var encString = Encoding.UTF8.GetString(encoded);
encString.Should().Be("ocu7BkU2bu1mq-yB2dL_4A");
}
public void StreamHeandlerTest()
{
var text1 = @"hello
who";
var stream = StreamHeandler.StringToStream(text1);
var zipStream = ZipCompress.Compress(stream);
var base64 = Base64Convert.ToBase64(zipStream);
var txt1 = StreamHeandler.StreamToString(base64);
var txt2 = txt1;
var base642 = StreamHeandler.StringToStream(txt2);
var unZipStream = Base64Convert.FrmBase64(base642);
var steam2 = ZipCompress.UnCompress(unZipStream);
var text2 = StreamHeandler.StreamToString(steam2);
Assert.AreEqual(text1, text2);
}
public static string AddBuildingWallBlock(string jsons)//添加幕墙板块信息
{
int count = 0;
try
{
string path = ConfigurationSettings.AppSettings["Savepath"];
AddBuildingBlock data = JsonConvert.DeserializeObject <AddBuildingBlock>(jsons);
BuildingWallBlock block = new BuildingWallBlock();
string Response = "";
for (int i = 0; i < data.blocks.Count(); i++)
{
block.adjustedLocationTopLeftX = data.blocks[i].adjustedLocationTopLeftX;
block.adjustedLocationTopLeftY = data.blocks[i].adjustedLocationTopLeftY;
block.blockLocationTopLeftX = data.blocks[i].blockLocationTopLeftX;
block.blockLocationTopLeftY = data.blocks[i].blockLocationTopLeftY;
block.buildingWallBlockNo = data.blocks[i].buildingWallBlockNo;
block.buildingWallId = data.buildingWallId;
block.buildingWallImageId = data.buildingWallImageId;
block.width = data.blocks[i].width;
block.height = data.blocks[i].height;
if (data.blocks[i].name == null)
{
data.blocks[i].name = data.blocks[i].value;
}
Response = HTTPService.AddWallBlock(block, data.blocks[i].name, data.blocks[i].value);
count++;
}
string savepath = path + DateTime.Now.ToString("yyyyMMddhhmmssff") + ".jpg";
Base64Convert.Base64ToFileAndSave(data.resultImageFile, savepath);//文件流保存到文件
int resultImageFileId = UploadFile.Upload(savepath);
File.Delete(savepath);
string result = HTTPService.UpdateWallimg(data.buildingWallImageId, resultImageFileId);
return(result);
}
catch (Exception ex)
{
Console.WriteLine(count);
Console.WriteLine(ex.Message + "," + ex.TargetSite + "," + ex.Source);
return(ex.Message + "," + ex.TargetSite + "," + ex.Source);
}
}
public static string UpdateBuildingAssemble(string jsons, string code, string img)//立面拼装信息
{
string save = ConfigurationSettings.AppSettings["Savepath"];
save += DateTime.Now.ToString("yyyyMMddhhmmssff") + ".jpg";
Base64Convert.Base64ToFileAndSave(img, save);
JObject jResult = JObject.Parse(jsons);
JArray jData = (JArray)jResult["data"];
List <AssembleInfo> results = jData.ToObject <List <AssembleInfo> >();
Console.WriteLine(code);
string result = "";
int buildingWallId = 0;
for (int i = 0; i < results.Count(); i++)
{
buildingWallId = HTTPService.UpdateBuidlingAssemble(results[i]);
}
result = HTTPService.UpdateBuildingWallAssemble(buildingWallId, code, save);
Console.WriteLine(result);
return(result);
}
private void PrinterLoggerCallback(string message, string printer_serial)
{
if (printer_serial == "Detecting")
{
message = "Detecting>" + message;
printer_serial = "00-00-00-00-00-000-000";
}
var spoolerMessage = new SpoolerMessage(MessageType.LoggingMessage, new PrinterSerialNumber(printer_serial), Base64Convert.Base64Encode(message));
lock (logging_queue)
{
logging_queue.Add(spoolerMessage);
}
}
public void DecodeString_GivenEncodedStringAndUrlSafeFlag_ReturnsPlainText(string base64, string expected)
{
Base64Convert.Decode(base64).Should().Be(expected);
}
public void Encode_GivenPlainTextAndUrlSafeFlag_ReturnsUrlSafeBase64String(string value, string expected)
{
Base64Convert.Encode(value, true).Should().Be(expected);
}
public void Encode_GivenPlainTextValue_ReturnsEncodedBase64String(string value, string expected)
{
Base64Convert.Encode(value).Should().Be(expected);
}
/// <summary>
/// 图像截取、矫正
/// </summary>
public static string Pic_Rectity(string FileName, string point_json, int originalImageFileId, int buildingWallId)
{
BuildingWallImage building = new BuildingWallImage();
string path = ConfigurationSettings.AppSettings["Savepath"];
string savepath = path + DateTime.Now.ToString("yyyyMMddhhmmss") + ".jpg";
Base64Convert.Base64ToFileAndSave(FileName, savepath);//文件流保存到文件
Positions positions = new Positions();
string filepath = path;
Mat src = Cv2.ImRead(savepath); //原始图像
List <Point> getpt = JsonConvert.DeserializeObject <List <Point> >(point_json);
Mat dst = new Mat();
//new Window("1", WindowMode.FreeRatio, src);
Mat roi = Mat.Zeros(src.Size(), MatType.CV_8U);
Point[] points = getpt.ToArray();
int maxX = points[0].X, maxY = points[0].Y, minX = points[0].X, minY = points[0].Y;
Point[][] contours = { points };
for (int i = 0; i < points.Length; i++)//求出最小坐标
{
if (points[i].X > maxX)
{
maxX = points[i].X;
}
if (points[i].Y > maxY)
{
maxY = points[i].Y;
}
if (points[i].X < minX)
{
minX = points[i].X;
}
if (points[i].Y < minY)
{
minY = points[i].Y;
}
}
int width = maxX - minX;
int height = maxY - minY;
Cv2.DrawContours(roi, contours, 0, Scalar.All(255), -1);
src.CopyTo(dst, roi);//保存到新画布
//new Window("转化前", WindowMode.FreeRatio, dst);
dst = dst.SubMat(new Rect(minX, minY, width, height));
Point2f[] pt = new Point2f[4];
for (int i = 0; i < points.Length; i++)//图像坐标
{
pt[i].X = points[i].X - minX;
pt[i].Y = points[i].Y - minY;
}
Point2f[] box = new Point2f[4];//画布角点
box[0] = new Point(0, 0);
box[1] = new Point(width, 0);
box[2] = new Point(width, height);
box[3] = new Point(0, height);
//图像的拉伸处理
var h = Cv2.GetPerspectiveTransform(pt, box);
Cv2.WarpPerspective(dst, dst, h, new Size(width, height));
string time = DateTime.Now.ToString("yyyyMMddhhmmssff") + ".jpg";
filepath += time;
Cv2.ImWrite(filepath, dst);
positions.FileName = ConfigurationSettings.AppSettings["Returnpath"] + time;
positions.point2 = Findarea(dst);
positions.imgFileId = UploadFile.Upload(savepath);
positions.adjustedImageFileId = UploadFile.Upload(filepath);
building.adjustedImageFileId = positions.adjustedImageFileId;
//building.selectedImageFileId = positions.adjustedImageFileId;
building.areaTopLeftX = points[0].X;
building.areaTopLeftY = points[0].Y;
building.areaTopRightX = points[1].X;
building.areaTopRightY = points[1].Y;
building.areaBottomLeftX = points[2].X;
building.areaBottomLeftY = points[2].Y;
building.areaBottomRightX = points[3].X;
building.areaBottomRightY = points[3].Y;
building.buildingWallId = buildingWallId;
building.originalImageFileId = originalImageFileId;
building.resultImageFileId = 1870;
string result = HTTPService.AddWallImage(building);
ResultMessage s = JsonConvert.DeserializeObject <ResultMessage>(result);
positions.buildingWallImageId = s.data;
string js = JsonConvert.SerializeObject(positions);
Console.WriteLine(js);
File.Delete(savepath);
return(js);
}
/// <summary>
/// 获取数据
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public DataResult PullData(DataParameter parameter)
{
LogHelper.Debug(GetType(), "准备获取数据", LogInfo.ObjectToMessage(parameter));
var success = true;
var result = new DataResult();
var crchash = new CrcHash();
PHPRPC_Client client = new PHPRPC_Client("http://localhost:4631/PullData.aspx");
IPullDataService pullDataService = (IPullDataService)client.UseService(typeof(IPullDataService));
//var pullDataService = AppCtx.Resolve<IPullDataService>("PullService");
//初始化异常
if (pullDataService == null)
{
LogHelper.Debug(GetType(), "获取接口失败");
return(null);
}
#region 开始请求
var beginParameter = new DataParameter();
beginParameter.Action = parameter.Action;
LogHelper.Debug(GetType(), "发送请求", LogInfo.ObjectToMessage(beginParameter));
var beginDataInfo = pullDataService.Begin(beginParameter);
if (beginDataInfo == null)
{
success = false;
result.ErrorId = (int)DataDictionary.ErrorType.DataPullBeginError;
result.ErrorMessage = "";
return(result);
}
else
{
result.Action = parameter.Action;
result.SplitCount = beginDataInfo.SpliteCount;
}
#endregion
#region 请求数据
//初始化容器以收集字符串
var sb = new StringBuilder(beginDataInfo.SpliteCount * dataLength);
LogHelper.Debug(GetType(), "开始请求具体数据");
for (int i = 0; i < beginDataInfo.SpliteCount; i++)
{
//请求数据
//todo:需优化，以重新请求超时未能请求到的数据
//var tcs = new TaskCompletionSource<DataSegment>();
//WaitCallback asyncWork = _ =>
//{
var dataSegment = pullDataService.Pull(beginDataInfo.DataId, i);
if (dataSegment == null)
{
//tcs.SetResult(null);
}
else
{
LogHelper.Debug(GetType(), string.Format("获取索引为{0}的数据:", i),
LogInfo.ObjectToMessage(dataSegment));
var stream = StreamHeandler.StringToStream(dataSegment.DataString);
dataSegment = !crchash.Hash(stream, dataSegment.Crccode)
? null
: dataSegment;
}
// tcs.SetResult(dataSegment);
// }
//};
//ThreadPool.QueueUserWorkItem(asyncWork);
//var task = tcs.Task;
//var taskResult = task.Result;
if (dataSegment != null)
{
sb.Insert(i * dataLength, dataSegment.DataString);
}
else
{
result.ErrorId = (int)DataDictionary.ErrorType.DataPullError;
result.ErrorMessage = "";
success = false;
break;
}
}
#endregion
#region 结束请求
var endData = pullDataService.End(beginDataInfo.DataId, !success);
LogHelper.Debug(GetType(), "结束请求数据", LogInfo.ObjectToMessage(endData));
if (endData == null)
{
result.ErrorId = (int)DataDictionary.ErrorType.DataPullEndError;
result.ErrorMessage = "";
success = false;
}
#endregion
if (success)
{
var stream = StreamHeandler.StringToStream(sb.ToString());
var base64 = Base64Convert.FrmBase64(stream);
LogHelper.Debug(GetType(), "解压请求到的数据");
var unZipStream = ZipCompress.UnCompress(base64);
result.CrcCode = crchash.GetHashCode(unZipStream);
LogHelper.Debug(GetType(), "生成校验码", result.CrcCode);
result.DataString = StreamHeandler.StreamToString(unZipStream);
//返回
}
return(result);
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
public DataResult PushData(DataParameter parameter)
{
LogHelper.Debug(GetType(), "准备发送数据", LogInfo.ObjectToMessage(parameter));
PHPRPC_Client client = new PHPRPC_Client("http://localhost:4631/PullData.aspx");
IPushDataService pushDataService = (IPushDataService)client.UseService(typeof(IPushDataService));
//var pushDataService = AppCtx.Resolve<IPushDataService>("PushService");
//初始化异常
if (pushDataService == null)
{
LogHelper.Warn(GetType(), "获取接口失败");
return(null);
}
var success = true;
var result = new DataResult();
var beginDataInfo = new DataInfo();
var crchash = new CrcHash();
result.DataId = Guid.NewGuid().ToString();
result.Action = parameter.Action;
result.CrcCode = parameter.CrcCode;
result.DataString = parameter.DataString;
var stream = StreamHeandler.StringToStream(parameter.DataString);
var zipStream = ZipCompress.Compress(stream);
var base64 = Base64Convert.ToBase64(zipStream);
var sb = new StringBuilder(StreamHeandler.StreamToString(base64));
var count = (int)Math.Ceiling(sb.Length / (double)dataLength);
result.SplitCount = count;
#region 准备发送数据
beginDataInfo.ActionId = parameter.Action;
beginDataInfo.DataId = result.DataId;
beginDataInfo.SpliteCount = count;
LogHelper.Debug(GetType(), "开始请求发送数据", LogInfo.ObjectToMessage(beginDataInfo));
pushDataService.Begin(beginDataInfo);
#endregion
#region 发送数据
LogHelper.Debug(GetType(), "开始发送数据");
for (int i = 0; i < count; i++)
{
var tcs = new TaskCompletionSource <bool>();
WaitCallback asyncWork = _ =>
{
var beginPos = i * dataLength;
var legth = i == count - 1 ? sb.Length - beginPos : dataLength;
var data = sb.ToString(beginPos, legth);
var dataSegment = new DataSegment();
dataSegment.DataId = result.DataId;
dataSegment.Crccode = crchash.GetHashCode(StreamHeandler.StringToStream(data));
dataSegment.DataString = data;
dataSegment.Index = i;
LogHelper.Debug(GetType(), string.Format("发送数据，ID：{0}，索引：{1}", result.DataId, i), LogInfo.ObjectToMessage(dataSegment));
pushDataService.Push(dataSegment);
tcs.SetResult(true);
};
ThreadPool.QueueUserWorkItem(asyncWork);
var task = tcs.Task;
var taskResult = task.Result;
if (!taskResult)
{
success = false;
break;
}
}
#endregion
#region 发送完成
var endResult = pushDataService.End(beginDataInfo.DataId, !success);
LogHelper.Debug(GetType(), "发送数据完成");
if (endResult == null)
{
success = false;
}
#endregion
return(result);
}
public void ProcessSpoolerMessage(SpoolerMessage message)
{
var asyncCallObject = (AsyncCallObject)null;
var flag = false;
if (message.Type == MessageType.RawData)
{
lock (thread_sync)
{
incoming_data = message.GetRawData();
}
}
else if (message.Type == MessageType.PluginMessage)
{
ProcessPluginMessageFromSpooler(message);
}
else if (message.Type == MessageType.LoggingMessage)
{
AddMessageToLog(Base64Convert.Base64Decode(message.Message));
lock (log)
{
log_updated = true;
}
}
else if (message.Type == MessageType.FullLoggingData)
{
string[] strArray = Base64Convert.Base64Decode(message.Message).Split('\n');
log.Clear();
foreach (var message1 in strArray)
{
AddMessageToLog(message1);
}
lock (log)
{
log_updated = true;
}
}
else if (message.Type == MessageType.BedLocationMustBeCalibrated || message.Type == MessageType.BedOrientationMustBeCalibrated || message.Type == MessageType.CheckGantryClips)
{
mylockID = Guid.Empty;
lockstatus.Value = PrinterLockStatus.Unlocked;
lock (waiting_object_lock)
{
if (waiting_object != null)
{
asyncCallObject = waiting_object;
waiting_object = null;
asyncCallObject.callresult = CommandResult.Failed_GantryClipsOrInvalidZ;
}
}
}
else if ((message.Type == MessageType.LockConfirmed || message.Type == MessageType.LockResult) && message.SerialNumber == Info.serial_number)
{
uint num = 0;
EventLockTimeOutCallBack callback = null;
CommandResult commandResult;
if (message.Type == MessageType.LockResult)
{
var s = message.Message.Substring(0, 8);
var str = message.Message.Substring(8);
try
{
num = uint.Parse(s);
commandResult = (CommandResult)Enum.Parse(typeof(CommandResult), str);
}
catch (ArgumentException ex)
{
commandResult = CommandResult.Failed_Exception;
}
if (commandResult == CommandResult.Success)
{
can_check_idle.Value = true;
return;
}
if (commandResult == CommandResult.Pending)
{
lockstatus.Value = PrinterLockStatus.OurLockPending;
return;
}
if (commandResult == CommandResult.LockForcedOpen)
{
lockstatus.Value = PrinterLockStatus.Unlocked;
}
else if (commandResult == CommandResult.LockLost_TimedOut)
{
lock (timeout_lock_sync)
{
callback = __LockTimeOutCallBack;
__LockTimeOutCallBack = null;
}
}
if (commandResult != CommandResult.CommandInterruptedByM0)
{
flag = true;
}
}
else
{
mylockID = Guid.Parse(message.Message);
commandResult = CommandResult.Success_LockAcquired;
lockstatus.Value = PrinterLockStatus.WeOwnLocked;
}
lock (waiting_object_lock)
{
if (waiting_object != null)
{
if (commandResult == CommandResult.SuccessfullyReceived)
{
if (waiting_object.callbackType != CallBackType.SuccessfullyReceived)
{
goto label_59;
}
}
asyncCallObject = waiting_object;
waiting_object = null;
}
}
label_59:
if (flag)
{
mylockID = Guid.Empty;
lockstatus.Value = PrinterLockStatus.Unlocked;
}
if (asyncCallObject != null)
{
if (num != 0U && (int)num != (int)asyncCallObject.callID)
{
commandResult = CommandResult.Failed_AsyncCallbackError;
}
asyncCallObject.callresult = commandResult;
}
if (callback != null)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(DoTimeoutCallBack), new Printer.TimeoutProperties(callback, (IPrinter)this));
}
}
if (asyncCallObject != null)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(DoAsyncCallBack), asyncCallObject);
}
if (OnProcessSpoolerMessage == null)
{
return;
}
OnProcessSpoolerMessage(message);
}
public string DecodeUsingBase64Convert()
{
return(Base64Convert.Decode(_data));
}
