public ParsedResult HandleResponse()
{
Utils.Logger.Info($"{m_WebRequest.responseCode} from {m_WebRequest.url}");
if (m_WebRequest.downloadHandler.text != null)
{
Utils.Logger.Info(m_WebRequest.downloadHandler.text);
}
m_Result = new ParsedResult();
if (m_WebRequest.isHttpError && m_WebRequest.responseCode >= 500)
{
m_Result.error = new Error
{
errorClass = ErrorClass.NetworkError,
type = "INTERNAL_SERVER_ERROR",
message = m_WebRequest.responseCode.ToString() + ": " + m_WebRequest.downloadHandler.text,
};
}
else if (m_WebRequest.isNetworkError && m_WebRequest.error != "Redirect limit exceeded")
{
m_Result.error = new Error
{
errorClass = ErrorClass.NetworkError,
type = "NETWORK_ERROR",
message = m_WebRequest.error,
};
}
else
{
m_Result = m_ResultParser(m_WebRequest, m_WebRequest.downloadHandler.text, m_Request);
}
return(m_Result);
}
private static void assertCorrectImage2result(String path, ExpandedProductParsedResult expected)
{
RSSExpandedReader rssExpandedReader = new RSSExpandedReader();
if (!File.Exists(path))
{
// Support running from project root too
path = Path.Combine("..\\..\\..\\Source", path);
}
#if !SILVERLIGHT
var image = new Bitmap(Image.FromFile(path));
#else
var image = new WriteableBitmap(0, 0);
image.SetSource(File.OpenRead(path));
#endif
BinaryBitmap binaryMap = new BinaryBitmap(new GlobalHistogramBinarizer(new BitmapLuminanceSource(image)));
int rowNumber = binaryMap.Height / 2;
BitArray row = binaryMap.getBlackRow(rowNumber, null);
Result theResult = rssExpandedReader.decodeRow(rowNumber, row, null);
Assert.IsNotNull(theResult);
Assert.AreEqual(BarcodeFormat.RSS_EXPANDED, theResult.BarcodeFormat);
ParsedResult result = ResultParser.parseResult(theResult);
Assert.AreEqual(expected, result);
}
private static void doTest(String contents,
String description,
String summary,
String location,
String startString,
String endString,
String organizer,
String[] attendees,
double latitude,
double longitude)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.CALENDAR, result.Type);
CalendarParsedResult calResult = (CalendarParsedResult)result;
Assert.AreEqual(description, calResult.Description);
Assert.AreEqual(summary, calResult.Summary);
Assert.AreEqual(location, calResult.Location);
Assert.AreEqual(startString, calResult.Start.ToString(DATE_TIME_FORMAT));
Assert.AreEqual(endString, calResult.End == null ? null : calResult.End.Value.ToString(DATE_TIME_FORMAT));
Assert.AreEqual(organizer, calResult.Organizer);
Assert.IsTrue((attendees == null && calResult.Attendees == null) ||
Equals(attendees, calResult.Attendees));
assertEqualOrNaN(latitude, calResult.Latitude);
assertEqualOrNaN(longitude, calResult.Longitude);
}
private static void MergeParsedResults(ParsedResult source,
ParsedResult destination)
{
if (source.Listings != null &&
source.Listings.Any())
{
foreach (var listingResult in source.Listings)
{
if (destination.Listings == null)
{
destination.Listings = new List <ListingResult>();
}
destination.Listings.Add(listingResult);
}
}
if (source.Errors != null &&
source.Errors.Any())
{
foreach (var parsedError in source.Errors)
{
if (destination.Errors == null)
{
destination.Errors = new List <ParsedError>();
}
destination.Errors.Add(parsedError);
}
}
}
/// <summary>
/// Inserts the given EntityDeclaration with the given
/// script at the end of the type declaration under the
/// cursor (e.g. class / struct).
/// </summary>
/// <remarks>
/// Alters the given script. Returns its CurrentDocument
/// property. Alters the given memberDeclaration, adding
/// Modifiers.Override to its Modifiers as well as removing
/// Modifiers.Virtual.
/// </remarks>
IDocument runOverrideTargetWorker
(Request request
, OmniSharpRefactoringContext refactoringContext
, ParsedResult parsedContent
, EntityDeclaration memberDeclaration
, OmniSharpScript script)
{
// Add override flag
memberDeclaration.Modifiers |= Modifiers.Override;
// Remove virtual flag
memberDeclaration.Modifiers &= ~Modifiers.Virtual;
// Remove abstract flag
memberDeclaration.Modifiers &= ~Modifiers.Abstract;
// The current type declaration, e.g. class, struct..
var typeDeclaration = parsedContent.SyntaxTree.GetNodeAt
(refactoringContext.Location
, n => n.NodeType == NodeType.TypeDeclaration);
// Even empty classes have nodes, so this works
var lastNode =
typeDeclaration.Children.Last();
script.InsertBefore
(node: lastNode
, newNode: memberDeclaration);
script.FormatText(memberDeclaration);
return(script.CurrentDocument);
}
private void ProcessScan(Result successfulScan, TimeSpan scanTime, CodeType scanType)
{
bool flag = true;
if (this._resultCache == null)
{
flag = true;
}
else
{
if (this._resultCache.Text.Length == successfulScan.Text.Length && this._resultCache.Text.Substring(1, 10) == successfulScan.Text.Substring(1, 10))
{
flag = false;
}
}
if (flag)
{
this._resultCache = successfulScan;
if (scanType == CodeType.QRCode)
{
ParsedResult scanObject = ResultParser.parseResult(successfulScan);
this.RaiseOnScanSuccessful(scanType, successfulScan.Text, scanObject, scanTime);
}
else
{
this.RaiseOnScanSuccessful(scanType, successfulScan.Text, successfulScan.Text, scanTime);
}
if (this.VibrateOnSuccess)
{
VibrateController @default = VibrateController.Default;
@default.Start(this.VibrationTime);
}
}
}
async Task WritePointsOfInterest(ParsedResult result)
{
var sql = $"INSERT INTO { result.RecordType }.point_of_interest "
+ $"( "
+ $" { result.RecordType }_id, "
+ $" is_override, "
+ $" poi_type, "
+ $" poi_name "
+ $") "
+ $"VALUES "
+ $"( "
+ $" @RecordId, "
+ $" @IsOverride, "
+ $" @PoiType, "
+ $" @PoiName "
+ $") ";
foreach (var poi in result.PointsOfInterest)
{
try
{
await RunAsync(conn => conn.ExecuteAsync(sql, new {
result.RecordId,
result.IsOverride,
PoiType = poi.Type,
PoiName = poi.Name
}));
}
catch (Exception ex)
{
Console.WriteLine($"Error processing { result.RecordType } with ID: { result.RecordId }. Error: { ex.Message }");
}
}
}
private static void doTest(String contents,
String title,
String[] names,
String pronunciation,
String[] addresses,
String[] emails,
String[] phoneNumbers,
String[] phoneTypes,
String org,
String[] urls,
String birthday,
String note)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.ADDRESSBOOK, result.Type);
AddressBookParsedResult addressResult = (AddressBookParsedResult)result;
Assert.AreEqual(title, addressResult.Title);
Assert.IsTrue(AreEqual(names, addressResult.Names));
Assert.AreEqual(pronunciation, addressResult.Pronunciation);
Assert.IsTrue(AreEqual(addresses, addressResult.Addresses));
Assert.IsTrue(AreEqual(emails, addressResult.Emails));
Assert.IsTrue(AreEqual(phoneNumbers, addressResult.PhoneNumbers));
Assert.AreEqual(phoneTypes, addressResult.PhoneTypes);
Assert.AreEqual(org, addressResult.Org);
Assert.IsTrue(AreEqual(urls, addressResult.URLs));
Assert.AreEqual(birthday, addressResult.Birthday);
Assert.AreEqual(note, addressResult.Note);
}
private static void doTestIsPossiblyMalicious(String uri, bool malicious)
{
var fakeResult = new ZXing.Result(uri, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(malicious ? ParsedResultType.TEXT : ParsedResultType.URI, result.Type);
}
public async Task Should_parse_the_two_segments_in_a_row()
{
const string message = @"MSH|^~\&|LIFTLAB||UBERMED||201701131234||ORU^R01|K113|P|
MSH|^~\&|LIFTLAB2||UBERMED2||201701131234||ORU^R01|K113|P|";
using (var stream = new StringReader(message))
{
StreamText text = await new TextReaderStreamTextReader(stream, Environment.NewLine).Text;
ParsedResult <HL7Entity> result = await Parser.ParseAsync(text, new TextSpan(0, text.Length));
MSHSegment msh = null;
Assert.IsTrue(result.TryGetEntity(0, out msh));
Assert.IsNotNull(msh);
Assert.IsNotNull(msh.SendingApplication);
Assert.IsTrue(msh.SendingApplication.IsPresent);
Assert.IsTrue(msh.SendingApplication.HasValue);
Assert.That(msh.SendingApplication.Value, Is.EqualTo("LIFTLAB"));
result = await result.NextAsync(Parser);
Assert.IsTrue(result.TryGetEntity(0, out msh));
Assert.IsNotNull(msh);
Assert.IsNotNull(msh.SendingApplication);
Assert.IsTrue(msh.SendingApplication.IsPresent);
Assert.IsTrue(msh.SendingApplication.HasValue);
Assert.That(msh.SendingApplication.Value, Is.EqualTo("LIFTLAB2"));
}
}
private Result decode(Uri uri, IDictionary <DecodeHintType, object> hints)
{
Bitmap image;
try
{
image = (Bitmap)Bitmap.FromFile(uri.LocalPath);
}
catch (Exception)
{
throw new FileNotFoundException("Resource not found: " + uri);
}
LuminanceSource source;
if (config.Crop == null)
{
source = new BitmapLuminanceSource(image);
}
else
{
int[] crop = config.Crop;
source = new BitmapLuminanceSource(image).crop(crop[0], crop[1], crop[2], crop[3]);
}
BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
if (config.DumpBlackPoint)
{
dumpBlackPoint(uri, image, bitmap);
}
Result result = new MultiFormatReader().decode(bitmap, hints);
if (result != null)
{
if (config.Brief)
{
Console.Out.WriteLine(uri + ": Success");
}
else
{
ParsedResult parsedResult = ResultParser.parseResult(result);
Console.Out.WriteLine(uri + " (format: " + result.BarcodeFormat + ", type: " +
parsedResult.Type + "):\nRaw result:\n" + result.Text + "\nParsed result:\n" +
parsedResult.DisplayResult);
Console.Out.WriteLine("Found " + result.ResultPoints.Length + " result points.");
for (int i = 0; i < result.ResultPoints.Length; i++)
{
ResultPoint rp = result.ResultPoints[i];
Console.Out.WriteLine(" Point " + i + ": (" + rp.X + ',' + rp.Y + ')');
}
}
}
else
{
Console.Out.WriteLine(uri + ": No barcode found");
}
return(result);
}
private static void doTestNotUri(String text)
{
ZXing.Result fakeResult = new ZXing.Result(text, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.TEXT, result.Type);
Assert.AreEqual(text, result.DisplayResult);
}
private Result decode(Uri uri, Bitmap image, string originalInput, IDictionary <DecodeHintType, object> hints)
{
LuminanceSource source;
if (config.Crop == null)
{
source = new BitmapLuminanceSource(image);
}
else
{
int[] crop = config.Crop;
source = new BitmapLuminanceSource(image).crop(crop[0], crop[1], crop[2], crop[3]);
}
if (config.DumpBlackPoint)
{
BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
dumpBlackPoint(uri, image, bitmap, source);
}
var reader = new BarcodeReader {
AutoRotate = config.AutoRotate
};
foreach (var entry in hints)
{
reader.Options.Hints.Add(entry.Key, entry.Value);
}
Result result = reader.Decode(source);
if (result != null)
{
if (config.Brief)
{
Console.Out.WriteLine(uri + ": Success");
}
else
{
ParsedResult parsedResult = ResultParser.parseResult(result);
var resultString = originalInput + " (format: " + result.BarcodeFormat + ", type: " + parsedResult.Type + "):" + Environment.NewLine;
for (int i = 0; i < result.ResultPoints.Length; i++)
{
ResultPoint rp = result.ResultPoints[i];
Console.Out.WriteLine(" Point " + i + ": (" + rp.X + ',' + rp.Y + ')');
}
resultString += "Raw result:" + Environment.NewLine + result.Text + Environment.NewLine;
resultString += "Parsed result:" + Environment.NewLine + parsedResult.DisplayResult + Environment.NewLine;
Console.Out.WriteLine(resultString);
ResultString = resultString;
}
}
else
{
var resultString = originalInput + ": No barcode found";
Console.Out.WriteLine(resultString);
ResultString = resultString;
}
return(result);
}
GivenTheFileREAResidentialCurrent_ParseThenSerializeThenDeserialize_ReturnsAResidentialAvailableListing(string fileName,
bool isFloorPlansCleared,
StatusType statusType)
{
// Arrange.
ResidentialListing expectedListing;
if (statusType == StatusType.Available)
{
expectedListing = FakeListings.CreateAFakeResidentialListing();
}
else
{
expectedListing = CreateAFakeEmptyResidentialListing("Residential-Sold-ABCD1234");
expectedListing.StatusType = StatusType.Sold;
expectedListing.SourceStatus = "sold";
expectedListing.Pricing = new SalePricing
{
SoldOn = new DateTime(2009, 1, 10, 12, 30, 00),
SoldPrice = 580000M,
SoldPriceText = "$580,000"
};
}
if (isFloorPlansCleared)
{
expectedListing.FloorPlans = new List <Media>();
}
var reaXml = File.ReadAllText(FakeDataFolder + fileName);
var reaXmlTransmorgrifier = new ReaXmlTransmorgrifier();
// Parse the xml, once for the first time.
var tempResult = reaXmlTransmorgrifier.Parse(reaXml);
var source = tempResult.Listings.First().Listing;
var json = source.SerializeObject();
// Act.
var result = JsonConvertHelpers.DeserializeObject(json);
// Assert.
var listingResult = new ListingResult
{
Listing = result,
SourceData = "blahblah"
};
var parsedResult = new ParsedResult
{
Listings = new List <ListingResult>
{
listingResult
},
UnhandledData = new List <string>(),
Errors = new List <ParsedError>(),
TransmorgrifierName = "REA"
};
AssertResidentialListing(parsedResult, expectedListing);
}
public static ParsedResult From(string abracadabra, ProcessModel processor)
{
if (processor.TryParse(abracadabra, out var result))
{
var r = new ParsedResult(result, processor.Language);
return(r);
}
return(null);
}
private static void doTest(String contents)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.EAN_13);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.ISBN, result.Type);
ISBNParsedResult isbnResult = (ISBNParsedResult)result;
Assert.AreEqual(contents, isbnResult.ISBN);
}
private static void AssertRentalListing(ParsedResult result,
RentalListing expectedListing)
{
result.ShouldNotBeNull();
result.Listings.Count.ShouldBe(1);
result.Errors.Count.ShouldBe(0);
result.UnhandledData.Count.ShouldBe(0);
RentalListingAssertHelpers.AssertRuralListing(result.Listings.First().Listing as RentalListing,
expectedListing);
}
private static void AssertParsingError(ParsedResult result,
ParsedError error)
{
result.ShouldNotBeNull();
result.Listings.Count.ShouldBe(0);
result.UnhandledData.Count.ShouldBe(0);
error.ShouldNotBeNull();
result.Errors.First().ExceptionMessage.ShouldBe(error.ExceptionMessage);
result.Errors.First().InvalidData.ShouldNotBeNullOrWhiteSpace();
}
private static void AssertResidentialListing(ParsedResult result,
ResidentialListing expectedListing)
{
result.ShouldNotBeNull();
result.Listings.Count.ShouldBe(1);
result.Errors.Count.ShouldBe(0);
result.UnhandledData.Count.ShouldBe(0);
result.TransmorgrifierName.ShouldBe("REA");
ResidentialListingAssertHelpers.AssertResidentialListing(result.Listings.First().Listing as ResidentialListing,
expectedListing);
}
private static void doTest(String contents, String normalized, BarcodeFormat format)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, format);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.PRODUCT, result.Type);
ProductParsedResult productResult = (ProductParsedResult)result;
Assert.AreEqual(contents, productResult.ProductID);
Assert.AreEqual(normalized, productResult.NormalizedProductID);
}
private static void doTest(String contents, String uri, String title)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.URI, result.Type);
URIParsedResult uriResult = (URIParsedResult)result;
Assert.AreEqual(uri, uriResult.URI);
Assert.AreEqual(title, uriResult.Title);
}
private static void doTest(String contents, String number, String title)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.TEL, result.Type);
TelParsedResult telResult = (TelParsedResult)result;
Assert.AreEqual(number, telResult.Number);
Assert.AreEqual(title, telResult.Title);
Assert.AreEqual("tel:" + number, telResult.TelURI);
}
async Task WriteReverseGeocodeData(ParsedResult result)
{
var sql = $"INSERT INTO { result.RecordType }.reverse_geocode "
+ $"( "
+ $" { result.RecordType }_id, "
+ $" is_override, "
+ $" formatted_address, "
+ $" administrative_area_level_1, "
+ $" administrative_area_level_2, "
+ $" administrative_area_level_3, "
+ $" country, "
+ $" locality, "
+ $" neighborhood, "
+ $" sub_locality_level_1, "
+ $" sub_locality_level_2, "
+ $" postal_code, "
+ $" postal_code_suffix, "
+ $" premise, "
+ $" route, "
+ $" street_number, "
+ $" sub_premise "
+ $") "
+ $"VALUES "
+ $"( "
+ $" @RecordId, "
+ $" @IsOverride, "
+ $" @FormattedAddress, "
+ $" @AdministrativeAreaLevel1, "
+ $" @AdministrativeAreaLevel2, "
+ $" @AdministrativeAreaLevel3, "
+ $" @Country, "
+ $" @Locality, "
+ $" @Neighborhood, "
+ $" @SubLocalityLevel1, "
+ $" @SubLocalityLevel2, "
+ $" @PostalCode, "
+ $" @PostalCodeSuffix, "
+ $" @Premise, "
+ $" @Route, "
+ $" @StreetNumber, "
+ $" @SubPremise "
+ $") ";
try
{
await RunAsync(conn => conn.ExecuteAsync(sql, result));
}
catch (Exception ex)
{
Console.WriteLine($"Error processing { result.RecordType } with ID: { result.RecordId }. Error: { ex.Message }");
}
}
private void ParseButton_Click(object sender, EventArgs e)
{
switch (ParseButton.Text)
{
case "Parse":
CsvReaderWriter crw = new CsvReaderWriter(FilePath_textBox.Text, requester.GetResultPath());
parsing_progressBar.Value = 0;
parsing_progressBar.Maximum = crw.getMax();
for (int i = 0; i < Streams_numericUpDown.Value; i++)
{
Thread t = new Thread(delegate ()
{
while (true)
{
string source;
lock (crw) { source = crw.getNextSource(); }
if (source == null) { MessageBox.Show("Done!"); break; }
ParsedResult parsedResult = requester.Parse(source);
Progress_Label.Invoke(new Action(() =>
{
parsing_progressBar.Value++;
Progress_Label.Text = parsing_progressBar.Value.ToString() + "/" + parsing_progressBar.Maximum.ToString();
TimeLeft_label.Text = getLeftTime();
}));
lock (crw) { crw.insertParsed(parsedResult); }
Thread.Sleep((int)Time_Out_numericUpDown.Value * 1000);
}
});
t.Start();
threads.Add(t);
}
break;
case "Pause":
foreach (var item in threads)
{
if (item.IsAlive) item.
}
break;
case "Continue":
break;
default:
break;
}
}
private static void doTestResult(String contents,
String goldenResult,
ParsedResultType type,
BarcodeFormat format)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, format);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.IsNotNull(result);
Assert.AreEqual(type, result.Type);
String displayResult = result.DisplayResult;
Assert.AreEqual(goldenResult, displayResult);
}
public void ValidateContentInvokesValidateNoOverlappedMeetings()
{
IList <IBookedRecords> content = new List <IBookedRecords> {
_meetings.First()
};
var parsedResult = new ParsedResult {
BookedRecords = content
};
_workTimeService.ValidateContent(parsedResult);
_validationService.Received().ValidateNoOverlappedMeetings(Arg.Any <IList <Meeting> >());
_errorResolver.DidNotReceive().Resolve(Arg.Any <IResult>());
}
async Task DeleteOverrideData(ParsedResult result, string tablename)
{
var sql = $"DELETE FROM { result.RecordType }.{ tablename } "
+ $" WHERE { result.RecordType }_id = { result.RecordId } "
+ $" AND is_override = TRUE ";
try
{
await RunAsync(conn => conn.ExecuteAsync(sql));
}
catch (Exception ex)
{
Console.WriteLine($"Error processing { result.RecordType } with ID: { result.RecordId }. Error: { ex.Message }");
}
}
/// <inheritdoc />
public ParsedResult Parse(string data,
Listing existingListing = null,
bool areBadCharactersRemoved = false)
{
if (string.IsNullOrWhiteSpace(data))
{
throw new ArgumentException(nameof(data));
}
var result = new ParsedResult()
{
TransmorgrifierName = Name
};
JToken token;
try
{
token = JToken.Parse(data);
}
catch (Exception exception)
{
result.Errors = new[]
{
new ParsedError(exception.Message, data)
};
return(result);
}
// Do we have a single listing or an array of listings?
if (token is JArray)
{
// We have multiple listings...
foreach (var item in token.Children())
{
var parsedResult = ParseObject(item.ToString());
MergeParsedResults(parsedResult, result);
}
}
else
{
// We have just a single listing ...
var parsedResult = ParseObject(data);
MergeParsedResults(parsedResult, result);
}
return(result);
}
private static void doTest(String contents,
String email,
String subject,
String body)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
Assert.AreEqual(ParsedResultType.EMAIL_ADDRESS, result.Type);
EmailAddressParsedResult emailResult = (EmailAddressParsedResult)result;
Assert.AreEqual(email, emailResult.EmailAddress);
Assert.AreEqual("mailto:" + email, emailResult.MailtoURI);
Assert.AreEqual(subject, emailResult.Subject);
Assert.AreEqual(body, emailResult.Body);
}
/// <summary>
/// Given the string contents for the barcode, check that it matches our expectations
/// </summary>
private static void doTest(String contents,
String ssid,
String password,
String type)
{
ZXing.Result fakeResult = new ZXing.Result(contents, null, null, BarcodeFormat.QR_CODE);
ParsedResult result = ResultParser.parseResult(fakeResult);
// Ensure it is a wifi code
Assert.AreEqual(ParsedResultType.WIFI, result.Type);
WifiParsedResult wifiResult = (WifiParsedResult)result;
Assert.AreEqual(ssid, wifiResult.Ssid);
Assert.AreEqual(password, wifiResult.Password);
Assert.AreEqual(type, wifiResult.NetworkEncryption);
}
