protected void CallBack(DbDataReader reader)
{
while (reader.Read())
{
var row = new LookupResponse()
{
Id = reader.GetInt32(0),
Description = reader.GetString(1),
Type = reader.GetString(2)
};
_list.Add(row);
}
}
public async Task Test_Lookup_Artists()
{
List <string> ids = new List <string>
{
"0oSGxfWSnnOXhD2fKuz2Gy",
"3dBVyJ7JuOMt4GE9607Qin"
};
_list = await _client.LookupAsync(ids, LookupType.Artists);
Assert.IsNotNull(_list.Artists);
Assert.IsTrue(_list.Artists.Count == ids.Count);
}
/// <summary>Snippet for Lookup</summary>
public void Lookup()
{
// Snippet: Lookup(string,ReadOptions,IEnumerable<Key>,CallSettings)
// Create client
DatastoreClient datastoreClient = DatastoreClient.Create();
// Initialize request argument(s)
string projectId = "";
ReadOptions readOptions = new ReadOptions();
IEnumerable <Key> keys = new List <Key>();
// Make the request
LookupResponse response = datastoreClient.Lookup(projectId, readOptions, keys);
// End snippet
}
public IActionResult FetchLookup([FromRoute] string ApiKey, [FromBody] LookupObj Param)
{
IActionResult response;
LookupResponse resp = new LookupResponse();
try
{
#region Call Get_Data_Set
LookupDAO ObjResponseDAO = new LookupDAO(_ConStr);
DataSet ds = ObjResponseDAO.FetchLookup(ApiKey, Param);
#endregion
var lookups = (from r in ds.Tables[0].AsEnumerable()
select new Lookup()
{
lookup_id = r.Field <int>("lookup_id"),
lookup_code = r.Field <string>("lookup_code"),
lookup_description = r.Field <string>("lookup_description"),
lookup_name = r.Field <string>("lookup_name")
}).ToList();
resp.statuscode = (int)Common.ResponseStatusCode.Success;
resp.message = "success";
resp.rows = lookups;
response = Ok(resp);
}
catch (Exception ex)
{
Common c = new Common();
ExceptionObj exobj = c.GetExceptionObjBase(ex);
exobj.form_name = "BodyController";
exobj.page_url = "api/Body/List";
int ReturnVal;
string ReturnMsg;
ExceptionDAO exd = new ExceptionDAO(_ConStr);
exd.SetExceptionLog(ApiKey, exobj, out ReturnVal, out ReturnMsg);
resp.statuscode = (int)Common.ResponseStatusCode.Exception;
resp.message = ex.Message.ToString();
response = BadRequest(resp);
}
return(response);
}
public override LookupResponse Lookup(LookupRequest request, CallSettings callSettings = null)
{
requests.Add(NormalizeRequest(request));
// Report "found" entities in the order they were presented in the constructor.
// Report everything else as deferred. Ignore "missing"...
var validKeys = keys.Where(k => request.Keys.Contains(k));
var response = new LookupResponse
{
Found = { validKeys.Take(maxPerRequest).Select(CreateEntityResult) },
Deferred = { validKeys.Skip(maxPerRequest) }
};
return(response);
}
/// <summary>Snippet for Lookup</summary>
public void Lookup_RequestObject()
{
// Snippet: Lookup(LookupRequest,CallSettings)
// Create client
DatastoreClient datastoreClient = DatastoreClient.Create();
// Initialize request argument(s)
LookupRequest request = new LookupRequest
{
ProjectId = "",
Keys = { },
};
// Make the request
LookupResponse response = datastoreClient.Lookup(request);
// End snippet
}
public async Task LookupAsync()
{
// Snippet: LookupAsync(string,ReadOptions,IEnumerable<Key>,CallSettings)
// Additional: LookupAsync(string,ReadOptions,IEnumerable<Key>,CancellationToken)
// Create client
DatastoreClient datastoreClient = DatastoreClient.Create();
// Initialize request argument(s)
string projectId = "";
ReadOptions readOptions = new ReadOptions();
IEnumerable <Key> keys = new List <Key>();
// Make the request
LookupResponse response = await datastoreClient.LookupAsync(projectId, readOptions, keys);
// End snippet
}
public void ShouldCreateLookupAsync()
{
// Arrange
ISystemApi systemApi = CreateSystemApi();
LookupRequest lookup = CreateLookup();
lookup.Id = null;
// Act
LookupResponse created = systemApi.CreateLookupsAsync(new SqlQuery(), lookup).Result.First();
// Assert
created.Id.ShouldBe(1);
Should.Throw <ArgumentException>(() => systemApi.CreateLookupsAsync(new SqlQuery()));
}
public async Task <IActionResult> AddAuthor([FromBody] LookupItemModel author)
{
try
{
var id = await _lookupDataRepository.CreateAuthor(author);
return(Ok(id));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemModel> .BuildErrorResponse("FailedAddAuthor", "Could not add Author");
return(BadRequest(response));
}
}
public async Task <IActionResult> DeleteAuthor(int id)
{
try
{
var status = await _lookupDataRepository.DeleteAuthor(id);
return(Ok(status));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemModel> .BuildErrorResponse("FailedUpadteAuthor", "Could not remove Author");
return(BadRequest(response));
}
}
public async Task LookupAsync_RequestObject()
{
// Snippet: LookupAsync(LookupRequest,CallSettings)
// Create client
DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();
// Initialize request argument(s)
LookupRequest request = new LookupRequest
{
ProjectId = "",
Keys = { },
};
// Make the request
LookupResponse response = await datastoreClient.LookupAsync(request);
// End snippet
}
public async Task <IActionResult> CreateAudioBook([FromBody] AudioBookItemModel model)
{
try
{
var audioBookDomain = _mapper.Map <Domain.AudioBook>(model);
var audioBookId = await _audioBookRepository.CreateAudioBook(audioBookDomain);
return(Ok(audioBookId));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemModel> .BuildErrorResponse("FailedAddAudioBook", "Could not add a new audiobook");
return(BadRequest(response));
}
}
public void LookupEntity()
{
string projectId = _fixture.ProjectId;
Key key = _fixture.LearnDatastoreKey;
// Sample: LookupEntity
DatastoreClient client = DatastoreClient.Create();
LookupResponse response = client.Lookup(
projectId,
new ReadOptions {
ReadConsistency = ReadConsistency.Eventual
},
new[] { key });
Entity entity = response.Found[0].Entity;
// End sample
}
public async Task LookupAsync2()
{
Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict);
LookupRequest request = new LookupRequest
{
ProjectId = "projectId-1969970175",
Keys = { },
};
LookupResponse expectedResponse = new LookupResponse();
mockGrpcClient.Setup(x => x.LookupAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <LookupResponse>(Task.FromResult(expectedResponse), null, null, null, null));
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
LookupResponse response = await client.LookupAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void Lookup2()
{
Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict);
LookupRequest request = new LookupRequest
{
ProjectId = "projectId-1969970175",
Keys = { },
};
LookupResponse expectedResponse = new LookupResponse();
mockGrpcClient.Setup(x => x.Lookup(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
LookupResponse response = client.Lookup(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <IActionResult> GetAudioBooks()
{
try
{
// get data from repo
var data = await _audioBookRepository.GetAudioBooks();
// map to model
var result = _mapper.Map <IEnumerable <AudioBookItemSummaryModel> >(data);
return(Ok(result));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemSummaryModel> .BuildErrorResponse("FailedGet", "Could not retrieve all audiobooks info");
return(BadRequest(response));
}
}
/// <summary>Snippet for LookupAsync</summary>
public async Task LookupRequestObjectAsync()
{
// Snippet: LookupAsync(LookupRequest, CallSettings)
// Additional: LookupAsync(LookupRequest, CancellationToken)
// Create client
DatastoreClient datastoreClient = await DatastoreClient.CreateAsync();
// Initialize request argument(s)
LookupRequest request = new LookupRequest
{
ReadOptions = new ReadOptions(),
Keys = { new Key(), },
ProjectId = "",
};
// Make the request
LookupResponse response = await datastoreClient.LookupAsync(request);
// End snippet
}
public List <Service> GetServices(List <DiscoveryConfig> discoveryConfigs)
{
Preconditions.CheckArgument(!Conditions.IsNullOrEmpty(discoveryConfigs), "discoveryConfigs should not be null or empty");
LookupRequest request = new LookupRequest()
{
DiscoveryConfigs = discoveryConfigs,
RegionId = DeploymentConfig.RegionId,
ZoneId = DeploymentConfig.ZoneId
};
LookupResponse response = this.Request <LookupResponse>(RestPaths.DISCOVERY_LOOKUP_FULL_PATH, request);
LogEvent(response.ResponseStatus, "discovery", "lookup");
if (response.ResponseStatus.IsSuccess())
{
return(response.Services);
}
throw new Exception("lookup services failed. " + response.ResponseStatus);
}
public async Task <Dictionary <string, Guid> > GetIDsByFingerprint(string fingerprint, int duration)
{
Configuration.ClientKey = "JRfomg6Xqm";
LookupService service = new LookupService();
LookupResponse response = await service.GetAsync(fingerprint, duration, new string[] { "recordings", "compress" });
// TODO: not here
//if (!string.IsNullOrEmpty(response.ErrorMessage))
//{
// Dialogs.ExceptionNotification en = new Dialogs.ExceptionNotification("Error", "Error in AcoustID WebAPI.");
// en.ShowDialog();
//}
//else if (response.Results.Count == 0)
//{
// Dialogs.ExceptionNotification en = new Dialogs.ExceptionNotification("Empty", "No results for given fingerprint.");
// en.ShowDialog();
//}
Guid resultAcoustID = Guid.Empty;
Guid resultMBID = Guid.Empty;
double maxScore = 0;
foreach (var result in response.Results)
{
if (result.Score > maxScore)
{
maxScore = result.Score;
resultAcoustID = new Guid(result.Id);
resultMBID = new Guid(result.Recordings.First().Id);
}
}
Dictionary <string, Guid> toReturn = new Dictionary <string, Guid>();
toReturn.Add("AcoustID", resultAcoustID);
toReturn.Add("MusicBrainzTrackId", resultMBID);
return(toReturn);
}
public async Task <IActionResult> UpdateAudioBook(int id, [FromBody] AudioBookItemModel model)
{
if (id != model.AudioBookId)
{
return(BadRequest());
}
try
{
var audioBookDomain = _mapper.Map <Domain.AudioBook>(model);
var status = await _audioBookRepository.UpdateAudioBook(audioBookDomain);
return(Ok(status));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemModel> .BuildErrorResponse("FailedAudioBookUpdate", "Could not update the audiobook");
return(BadRequest(response));
}
}
public void Lookup()
{
Mock <Datastore.DatastoreClient> mockGrpcClient = new Mock <Datastore.DatastoreClient>(MockBehavior.Strict);
LookupRequest expectedRequest = new LookupRequest
{
ProjectId = "projectId-1969970175",
ReadOptions = new ReadOptions(),
Keys = { },
};
LookupResponse expectedResponse = new LookupResponse();
mockGrpcClient.Setup(x => x.Lookup(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
string projectId = "projectId-1969970175";
ReadOptions readOptions = new ReadOptions();
IEnumerable <Key> keys = new List <Key>();
LookupResponse response = client.Lookup(projectId, readOptions, keys);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
private void ParseResponse(LookupResponse response, List <Tuple <LocalBook, AcoustId> > toLookup, double threshold)
{
if (response == null)
{
return;
}
// The API will give errors if fingerprint isn't found or is invalid.
// We don't want to stop the entire import because the fingerprinting failed
// so just log and return.
foreach (var fileResponse in response.Fingerprints)
{
if (fileResponse.Results.Count == 0)
{
_logger.Debug("No results for given fingerprint.");
continue;
}
foreach (var result in fileResponse.Results.Where(x => x.Recordings != null))
{
_logger.Trace("Found: {0}, {1}, {2}", result.Id, result.Score, string.Join(", ", result.Recordings.Select(x => x.Id)));
}
var ids = fileResponse.Results.Where(x => x.Score > threshold && x.Recordings != null).SelectMany(y => y.Recordings.Select(z => z.Id)).Distinct().ToList();
_logger.Trace("All recordings: {0}", string.Join("\n", ids));
toLookup[fileResponse.index].Item1.AcoustIdResults = ids;
}
_logger.Debug("Fingerprinting complete.");
var serializerSettings = Json.GetSerializerSettings();
serializerSettings.Formatting = Formatting.None;
var output = new { Fingerprints = toLookup.Select(x => new { Path = x.Item1.Path, AcoustIdResults = x.Item1.AcoustIdResults }) };
_logger.Debug($"*** FingerprintingService TestCaseGenerator ***\n{JsonConvert.SerializeObject(output, serializerSettings)}");
}
public async Task <IActionResult> GetAudioBook(int id)
{
if (id == 0)
{
return(NotFound());
}
try
{
// this._telemetry.TrackEvent(new EventTelemetry($"AudioBookController : GetAudioBook - Start retrieving audiobook with Id : {id }"));
var data = await _audioBookRepository.GetAudioBookById(id);
var result = _mapper.Map <AudioBookItemModel>(data);
// this._telemetry.TrackEvent(new EventTelemetry($"AudioBookController : GetAudioBook - Finish retrieving audiobook with Id : {id}"));
return(Ok(result));
}
catch (Exception ex)
{
this._telemetry.TrackException(ex);
var response = LookupResponse <AudioBookItemModel> .BuildErrorResponse("FailedGet", "Could not retrieve audiobook data");
return(BadRequest(response));
}
}
public void Lookup()
{
moq::Mock <Datastore.DatastoreClient> mockGrpcClient = new moq::Mock <Datastore.DatastoreClient>(moq::MockBehavior.Strict);
LookupRequest request = new LookupRequest
{
ReadOptions = new ReadOptions(),
Keys = { new Key(), },
ProjectId = "project_id43ad98b0",
};
LookupResponse expectedResponse = new LookupResponse
{
Found = { new EntityResult(), },
Missing = { new EntityResult(), },
Deferred = { new Key(), },
};
mockGrpcClient.Setup(x => x.Lookup(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
DatastoreClient client = new DatastoreClientImpl(mockGrpcClient.Object, null);
LookupResponse response = client.Lookup(request.ProjectId, request.ReadOptions, request.Keys);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <IResponse> Lookup(string qname, string qtype)
{
string query;
try
{
bool removeTrailingDot = _configRoot.GetValue <bool>("RemoveTrailingDot");
if (removeTrailingDot && qname.EndsWith("."))
{
qname = qname.Remove(qname.Length - 1);
}
// We need to ask Transaction Manager if we need to hook the lookup query
if (_transactionManager.Transactions().Any() && _transactionManager.TransactionExistsWith(qname, qtype))
{
_logger.LogInformation($"Found existing Transaction which handles {qname} {qtype} => Hooking this query with Transaction Manager");
// returns null when last transaction for this record was DELETE else it returns the record itself
IRecord transactionRecord = _transactionManager.GetLastTransactionRecord(qname, qtype);
if (transactionRecord is null)
{
_logger.LogInformation("Transaction Manager returned NULL => Record was deleted in Transaction => returning false");
throw new NoValuesException();
}
else
{
_logger.LogInformation("Transaction Manager recturned a record => Record was inserted / updated in transaction => returning record");
_logger.LogDebug(transactionRecord.ToString());
return(new LookupResponse()
{
result = new List <IRecord>()
{
transactionRecord
}
});
}
}
if (qtype == "ANY")
{
query = $"SELECT domain_id,name,type,content,ttl,disabled,auth FROM records WHERE LOWER(name)='{qname.ToLower()}'";
}
else
{
query = $"SELECT domain_id,name,type,content,ttl,disabled,auth FROM records WHERE LOWER(name)='{qname.ToLower()}' AND type='{qtype}'";
}
using (QueryResult queryResult = await _rqliteService.QueryAsync(query, ReadConsistencyLevel.None))
{
return(LookupResponse.FromValues(queryResult.Results.FirstOrDefault().Values));
}
}
catch (NoValuesException)
{
_logger.LogDebug($"No record found for {qname}|{qtype}");
return(new BoolResponse {
result = false
});
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(new BoolResponse {
Log = new List <string>()
{
$"Failed to lookup {qname}|{qtype}"
}, result = false
});
}
}
#pragma warning disable 1998
public async Task <LookupResponse[]> LookupAsync(string product, params string[] phoneNumbers)
#pragma warning restore 1998
{
if (phoneNumbers.Length != 1)
{
throw new NotImplementedException(); //TODO: Import modified Heijden
}
var resolver = new Resolver(Address)
{
TransportType = TransportType.Udp,
UseCache = false,
TimeOut = 20,
Retries = 1
};
var strName = Resolver.GetArpaFromEnum(phoneNumbers.Single());
if (strName.EndsWith(".e164.arpa.") && !string.IsNullOrEmpty(product))
{
strName = strName.Insert(strName.Length - ".e164.arpa.".Length, "." + product.ToLower());
}
var response = resolver.Query(strName, QType.NAPTR, QClass.IN);
var naptrRecord = response.Answers.Select(answer => answer.RECORD).OfType <RecordNAPTR>().FirstOrDefault();
// ReSharper disable once PossibleNullReferenceException
var responseParts = naptrRecord.REGEXP.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (responseParts.Length == 0)
{
return(null);
}
// ReSharper disable once PossibleNullReferenceException
var match = _resultRegex.Value.Match(responseParts[0]);
var lookupResponse = new LookupResponse
{
InputPhoneNumber = phoneNumbers.Single(),
MSISDN = match.Success ? match.Groups[1].Value : null,
MobileCountryCode = match.Success ? match.Groups[3].Value : null,
MobileNetworkCode = match.Success ? match.Groups[2].Value : null
};
for (var i = 1; i < responseParts.Length; i++)
{
var fieldMatch = _resultValueRegex.Value.Match(responseParts[i]);
if (!fieldMatch.Success)
{
continue;
}
switch (fieldMatch.Groups[1].Value)
{
case "npdi":
lookupResponse.NPDI = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
case "price":
lookupResponse.Price = decimal.Parse(fieldMatch.Groups[2].Value, CultureInfo.InvariantCulture.NumberFormat);
break;
case "nrhmnc":
lookupResponse.PortedSourceMobileNetworkCode = fieldMatch.Groups[2].Value;
break;
case "imsi":
lookupResponse.IMSI = fieldMatch.Groups[2].Value;
break;
case "msc":
lookupResponse.MSC = fieldMatch.Groups[2].Value;
break;
case "isroaming":
lookupResponse.IsRoaming = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
case "rmcc":
lookupResponse.RoamingMobileCountryCode = fieldMatch.Groups[2].Value;
break;
case "isabsent":
lookupResponse.IsAbsent = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
}
}
return(new[] { lookupResponse }); //TODO: Make async response from Task.Factory.FromAsync(resolver.BeginResolve, resolver.EndResolve)
// https://blog.justjuzzy.com/2012/10/turn-iasyncresult-code-into-await-keyword/
}
private void RequestLoop()
{
DebugWrite("RequestLoop starting!", 6);
DateTime startTime = DateTime.Now;
double minWaitTime = 2.0D;
List<LookupRequest> requests = new List<LookupRequest>(); ;
while (true)
{
try
{
if (RequestQueueCount() == 0)
{
requestLoopHandle.Reset();
DebugWrite("RequestQueue empty, waiting...", 6);
requestLoopHandle.WaitOne();
}
if (!isEnabled)
{
DebugWrite("Plugin disabled, RequestLoop aborting...", 6);
break;
}
DebugWrite("RequestLoop active...", 6);
requests.Clear();
DebugWrite("RequestLoop locking lookupRequests (creating local copy)", 6);
lock (lookupRequestLock)
{
requests = new List<LookupRequest>(lookupRequests);
}
DebugWrite("RequestLoop releasing lookupRequests (creating local copy)", 6);
DebugWrite(lookupRequests.Count + " lookupRequests in queue...", 5);
for (int i = 0; i < requests.Count; i++)
{
DebugWrite("Performing lookupRequest #" + i + "...", 5);
String jsonData = PerformLookup(requests[i].PlayerName, requests[i].RequestType, startTime, minWaitTime);
startTime = DateTime.Now;
if (!isEnabled)
{
DebugWrite("Plugin disabled, RequestLoop aborting...", 6);
return;
}
LookupResponse response = new LookupResponse(requests[i].PluginName, requests[i].PluginMethod, requests[i].PlayerName, jsonData);
DebugWrite("RequestLoop locking lookupResponses (adding new response)", 6);
lock (lookupResponseLock)
{
lookupResponses.Add(response);
}
DebugWrite("RequestLoop releasing lookupResponses (adding new response)", 6);
DebugWrite("RequestLoop locking lookupRequests (deleting old request)", 6);
lock (lookupRequestLock)
{
for (int j = 0; j < lookupRequests.Count; j++)
{
if (lookupRequests[j].Equals(requests[i]))
{
lookupRequests.RemoveAt(j);
break;
}
}
}
DebugWrite("RequestLoop releasing lookupRequests (deleting old request)", 6);
//requests.Remove(requests[i]);
responseLoopHandle.Set();
DebugWrite("Finished lookupRequest #" + i + "...", 5);
}
DebugWrite("Finished all lookupRequests...", 5);
}
catch (Exception e)
{
if (typeof(ThreadAbortException).Equals(e.GetType()))
{
Thread.ResetAbort();
return;
}
DebugWrite("Exception in RequestLoop! " + e.ToString(), 3);
}
}
responseLoopHandle.Set();
DebugWrite("RequestLoop finished!", 6);
}
#pragma warning disable 1998
public async Task<LookupResponse[]> LookupAsync(string product, params string[] phoneNumbers)
#pragma warning restore 1998
{
if (phoneNumbers.Length != 1)
{
throw new NotImplementedException(); //TODO: Import modified Heijden
}
var resolver = new Resolver(Address)
{
TransportType = TransportType.Udp,
UseCache = false,
TimeOut = 20,
Retries = 1
};
var strName = Resolver.GetArpaFromEnum(phoneNumbers.Single());
if (strName.EndsWith(".e164.arpa.") && !string.IsNullOrEmpty(product))
{
strName = strName.Insert(strName.Length - ".e164.arpa.".Length, "." + product.ToLower());
}
var response = resolver.Query(strName, QType.NAPTR, QClass.IN);
var naptrRecord = response.Answers.Select(answer => answer.RECORD).OfType<RecordNAPTR>().FirstOrDefault();
// ReSharper disable once PossibleNullReferenceException
var responseParts = naptrRecord.REGEXP.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (responseParts.Length == 0) return null;
// ReSharper disable once PossibleNullReferenceException
var match = _resultRegex.Value.Match(responseParts[0]);
var lookupResponse = new LookupResponse
{
InputPhoneNumber = phoneNumbers.Single(),
MSISDN = match.Success ? match.Groups[1].Value : null,
MobileCountryCode = match.Success ? match.Groups[3].Value : null,
MobileNetworkCode = match.Success ? match.Groups[2].Value : null
};
for (var i = 1; i < responseParts.Length; i++)
{
var fieldMatch = _resultValueRegex.Value.Match(responseParts[i]);
if (!fieldMatch.Success) continue;
switch (fieldMatch.Groups[1].Value)
{
case "npdi":
lookupResponse.NPDI = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
case "price":
lookupResponse.Price = decimal.Parse(fieldMatch.Groups[2].Value, CultureInfo.InvariantCulture.NumberFormat);
break;
case "nrhmnc":
lookupResponse.PortedSourceMobileNetworkCode = fieldMatch.Groups[2].Value;
break;
case "imsi":
lookupResponse.IMSI = fieldMatch.Groups[2].Value;
break;
case "msc":
lookupResponse.MSC = fieldMatch.Groups[2].Value;
break;
case "isroaming":
lookupResponse.IsRoaming = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
case "rmcc":
lookupResponse.RoamingMobileCountryCode = fieldMatch.Groups[2].Value;
break;
case "isabsent":
lookupResponse.IsAbsent = Convert.ToBoolean(int.Parse(fieldMatch.Groups[2].Value));
break;
}
}
return new[] { lookupResponse }; //TODO: Make async response from Task.Factory.FromAsync(resolver.BeginResolve, resolver.EndResolve)
// https://blog.justjuzzy.com/2012/10/turn-iasyncresult-code-into-await-keyword/
}
