public void UploadPhotoToAlbum(string aid, long optionalGroupId, byte[] photoData, Action <BackendResult <Photo, ResultCode> > callback)
{
this.GetPhotoUploadServerAlbum(aid, optionalGroupId, (Action <BackendResult <UploadServerAddress, ResultCode> >)(getUplResp =>
{
if (getUplResp.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <Photo, ResultCode>(getUplResp.ResultCode));
}
else
{
string uploadUrl = getUplResp.ResultData.upload_url;
MemoryStream ms = new MemoryStream(photoData);
MemoryStream memoryStream = ms;
string paramName = "file1";
string uploadContentType = "image";
Action <JsonResponseData> resultCallback = (Action <JsonResponseData>)(jsonResult =>
{
ms.Close();
if (!jsonResult.IsSucceeded)
{
callback(new BackendResult <Photo, ResultCode>(ResultCode.UnknownError));
}
else
{
UploadPhotoResponseData uploadData = JsonConvert.DeserializeObject <UploadPhotoResponseData>(jsonResult.JsonString);
this.SavePhoto(uploadData.aid, optionalGroupId, uploadData, callback);
}
});
string fileName = "MyImage.jpg";
// ISSUE: variable of the null type
// ISSUE: variable of the null type
JsonWebRequest.Upload(uploadUrl, (Stream)memoryStream, paramName, uploadContentType, resultCallback, fileName, null, null);
}
}));
}
public void ReverseGeocodeToAddress(double latitude, double longitude, Action <BackendResult <string, ResultCode> > callback)
{
JsonWebRequest.SendHTTPRequestAsync(string.Format(MapsService._reverseGeocodeUriFormat, this.CoordinatesToString(latitude, longitude), CultureInfo.CurrentCulture), (Action <JsonResponseData>)(data =>
{
if (!data.IsSucceeded)
{
callback(new BackendResult <string, ResultCode>(ResultCode.CommunicationFailed));
}
else
{
GoogleGeocode googleGeocode = JsonConvert.DeserializeObject <GoogleGeocode>(data.JsonString);
if (googleGeocode.results != null && googleGeocode.results.Count > 0)
{
GoogleGeocodeResult googleGeocodeResult = googleGeocode.results.FirstOrDefault <GoogleGeocodeResult>((Func <GoogleGeocodeResult, bool>)(r =>
{
if (r.address_components != null)
{
return(r.address_components.Count > 0);
}
return(false);
}));
if (googleGeocodeResult != null)
{
callback(new BackendResult <string, ResultCode>(ResultCode.Succeeded, googleGeocodeResult.formatted_address));
return;
}
}
callback(new BackendResult <string, ResultCode>(ResultCode.UnknownError));
}
}), null);
}
private static void ReadCallBack(IAsyncResult asyncResult)
{
JsonWebRequest.RequestState asyncState = (JsonWebRequest.RequestState)asyncResult.AsyncState;
try
{
Stream streamResponse = asyncState.streamResponse;
int count = streamResponse.EndRead(asyncResult);
if (count > 0)
{
asyncState.readBytes.AddRange(((IEnumerable <byte>)asyncState.BufferRead).Take <byte>(count));
streamResponse.BeginRead(asyncState.BufferRead, 0, 5000, new AsyncCallback(JsonWebRequest.ReadCallBack), asyncState);
}
else
{
string stringContent = Encoding.UTF8.GetString(asyncState.readBytes.ToArray(), 0, asyncState.readBytes.Count);
JsonWebRequest.SafeClose(asyncState);
Logger.Instance.Info("<<<<<<<<<<<<JSONWebRequest duration {0} ms. URI {1} ---->>>>> {2}", (DateTime.Now - asyncState.startTime).TotalMilliseconds, ((WebRequest)asyncState.request).RequestUri.OriginalString, stringContent);
JsonWebRequest.SafeInvokeCallback(asyncState.resultCallback, true, stringContent);
}
}
catch (Exception ex)
{
Logger.Instance.Error("ReadCallBack failed.", ex);
JsonWebRequest.SafeClose(asyncState);
JsonWebRequest.SafeInvokeCallback(asyncState.resultCallback, false, null);
}
}
public void SaveProfilePhoto(Rect thumbnailRect, byte[] photoData, Action <BackendResult <ProfilePhoto, ResultCode> > callback)
{
this.GetPhotoUploadServer((Action <BackendResult <UploadServerAddress, ResultCode> >)(res =>
{
if (res.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <ProfilePhoto, ResultCode>(res.ResultCode));
}
else
{
string uploadUrl = res.ResultData.upload_url;
// ISSUE: explicit reference operation
if (((Rect)@thumbnailRect).Width != 0.0)
{
// ISSUE: explicit reference operation
// ISSUE: explicit reference operation
// ISSUE: explicit reference operation
string str = string.Format("&_square_crop={0},{1},{2}&_full={0},{1},{2},{2}", (int)((Rect)@thumbnailRect).X, (int)((Rect)@thumbnailRect).Y, (int)((Rect)@thumbnailRect).Width);
uploadUrl += str;
}
MemoryStream memoryStream = new MemoryStream(photoData);
JsonWebRequest.Upload(uploadUrl, (Stream)memoryStream, "photo", "image", (Action <JsonResponseData>)(jsonResult =>
{
if (!jsonResult.IsSucceeded)
{
callback(new BackendResult <ProfilePhoto, ResultCode>(ResultCode.UnknownError));
}
else
{
this.SaveProfilePhoto(JsonConvert.DeserializeObject <UploadPhotoResponseData>(jsonResult.JsonString), callback);
}
}), "MyImage.jpg", null, null);
}
}));
}
private static void DoDispatch2(string baseUrl, string methodName, Dictionary <string, string> parameters)
{
parameters["v"] = VKConstants.API_VERSION;
AutorizationData autorizationData1 = VKRequestsDispatcher._autorizationData;
if (!string.IsNullOrEmpty(autorizationData1 != null ? autorizationData1.access_token : null))
{
parameters["access_token"] = VKRequestsDispatcher._autorizationData.access_token;
}
VKRequestsDispatcher.AddLangParameter(parameters);
AutorizationData autorizationData2 = VKRequestsDispatcher._autorizationData;
if (!string.IsNullOrEmpty(autorizationData2 != null ? autorizationData2.secret : null))
{
if (parameters.ContainsKey("sig"))
{
parameters.Remove("sig");
}
string str1 = JsonWebRequest.ConvertDictionaryToQueryString(parameters, false);
if (str1 != string.Empty)
{
str1 = "?" + str1;
}
string str2 = VKRequestsDispatcher.HashString("/method/" + methodName + str1 + VKRequestsDispatcher._autorizationData.secret);
parameters["sig"] = str2.ToLower();
}
JsonWebRequest.SendHTTPRequestAsync(!VKRequestsDispatcher.USE_HTTP ? "https://" + baseUrl : "http://" + baseUrl, parameters, (Action <JsonResponseData>)(jsonResp =>
{
if (jsonResp.IsSucceeded)
{
}
}));
}
public void UploadVideo(Stream stream, bool isPrivate, long albumId, long groupId, string name, string description, Action <BackendResult <SaveVideoResponse, ResultCode> > callback, Action <double> progressCallback = null, Cancellation c = null, PrivacyInfo privacyViewInfo = null, PrivacyInfo privacyCommentInfo = null)
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters["is_private"] = isPrivate ? "1" : "0";
if (groupId != 0L)
{
parameters["group_id"] = groupId.ToString();
}
if (albumId != 0L)
{
parameters["album_id"] = albumId.ToString();
}
if (!string.IsNullOrEmpty(name))
{
parameters["name"] = name;
}
if (!string.IsNullOrEmpty(description))
{
parameters["description"] = description;
}
if (privacyViewInfo != null && groupId == 0L)
{
parameters["privacy_view"] = privacyViewInfo.ToString();
}
if (privacyCommentInfo != null && groupId == 0L)
{
parameters["privacy_comment"] = privacyCommentInfo.ToString();
}
VKRequestsDispatcher.DispatchRequestToVK <SaveVideoResponse>("video.save", parameters, (Action <BackendResult <SaveVideoResponse, ResultCode> >)(res =>
{
if (res.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <SaveVideoResponse, ResultCode>(res.ResultCode));
}
else
{
SaveVideoResponse svr = res.ResultData;
JsonWebRequest.Upload(svr.upload_url, stream, "video_file", "video", (Action <JsonResponseData>)(uploadRes =>
{
if (uploadRes.IsSucceeded)
{
callback(new BackendResult <SaveVideoResponse, ResultCode>(ResultCode.Succeeded, svr));
}
else
{
callback(new BackendResult <SaveVideoResponse, ResultCode>(ResultCode.UnknownError));
}
}), null, progressCallback, c);
}
}), null, false, true, new CancellationToken?(), null);
}
public static void SendHTTPRequestAsync(string baseUri, Dictionary <string, string> parameters, Action <JsonResponseData> resultCallback, bool usePost = true, bool lowPriority = false, bool pageDataRequest = true)
{
if (lowPriority)
{
Action <Action> action = (Action <Action>)(a => JsonWebRequest.SendHTTPRequestAsync(baseUri, parameters, (Action <JsonResponseData>)(res =>
{
a();
resultCallback(res);
}), usePost, false, true));
JsonWebRequest._lowPriorityQueue.AddToDelayedExecutionQueue(action, baseUri);
}
else
{
Logger.Instance.Info(">>>>>>>>>>>>>>>Starting GETAsync concurrentRequestsNo = {0} ; baseUri = {1}; parameters = {2}", JsonWebRequest._currentNumberOfRequests, baseUri, JsonWebRequest.GetAsLogString(parameters));
Interlocked.Increment(ref JsonWebRequest._currentNumberOfRequests);
string queryString = JsonWebRequest.ConvertDictionaryToQueryString(parameters, true);
JsonWebRequest.RequestState myRequestState = new JsonWebRequest.RequestState();
try
{
myRequestState.resultCallback = resultCallback;
string requestUriString = baseUri;
if (!usePost && queryString.Length > 0)
{
requestUriString = requestUriString + "?" + queryString;
}
HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(requestUriString);
myHttpWebRequest.UserAgent = AppInfo.AppVersionForUserAgent;
myRequestState.request = myHttpWebRequest;
if (usePost)
{
myHttpWebRequest.ContentType = "application/x-www-form-urlencoded";
myHttpWebRequest.Method = "POST";
myHttpWebRequest.BeginGetRequestStream((AsyncCallback)(ar =>
{
using (StreamWriter streamWriter = new StreamWriter(myHttpWebRequest.EndGetRequestStream(ar)))
streamWriter.Write(queryString);
myHttpWebRequest.BeginGetCompressedResponse(new AsyncCallback(JsonWebRequest.RespCallback), myRequestState);
}), null);
}
else
{
myHttpWebRequest.BeginGetCompressedResponse(new AsyncCallback(JsonWebRequest.RespCallback), myRequestState);
}
}
catch (Exception ex)
{
Logger.Instance.Error("GetJsonAsync failed.", ex);
JsonWebRequest.SafeClose(myRequestState);
JsonWebRequest.SafeInvokeCallback(myRequestState.resultCallback, false, null);
}
}
}
public void GetAlbumArtwork(string search, Action <BackendResult <AlbumArtwork, ResultCode> > callback)
{
string format = "https://itunes.apple.com/search?media=music&limit=1&version=2&term={0}";
search = HttpUtility.UrlEncode(search);
if (this._cachedResults.ContainsKey(search))
{
callback(new BackendResult <AlbumArtwork, ResultCode>(ResultCode.Succeeded, new AlbumArtwork()
{
ImageUri = this._cachedResults[search]
}));
}
else
{
JsonWebRequest.SendHTTPRequestAsync(string.Format(format, search), (Action <JsonResponseData>)(resp =>
{
if (resp.IsSucceeded)
{
try
{
AudioService.ItunesList itunesList = JsonConvert.DeserializeObject <AudioService.ItunesList>(resp.JsonString);
if (!itunesList.results.IsNullOrEmpty())
{
AudioService.ItunesAlbumArt result = itunesList.results[0];
AlbumArtwork albArt = new AlbumArtwork()
{
ImageUri = result.artworkUrl100.Replace("100x100", "600x600")
};
Execute.ExecuteOnUIThread((Action)(() =>
{
this._cachedResults[search] = albArt.ImageUri;
callback(new BackendResult <AlbumArtwork, ResultCode>(ResultCode.Succeeded, albArt));
}));
}
else
{
callback(new BackendResult <AlbumArtwork, ResultCode>(ResultCode.Succeeded, new AlbumArtwork()));
}
}
catch (Exception)
{
callback(new BackendResult <AlbumArtwork, ResultCode>(ResultCode.UnknownError));
}
}
else
{
callback(new BackendResult <AlbumArtwork, ResultCode>(ResultCode.CommunicationFailed));
}
}), null);
}
}
public void UploadAudio(Stream stream, string artist, string title, Action <BackendResult <AudioObj, ResultCode> > callback, Action <double> progressCallback = null, Cancellation cancellation = null)
{
VKRequestsDispatcher.DispatchRequestToVK <VKClient.Common.Backend.DataObjects.UploadServerAddress>("audio.getUploadServer", new Dictionary <string, string>(), (Action <BackendResult <VKClient.Common.Backend.DataObjects.UploadServerAddress, ResultCode> >)(result =>
{
if (result.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <AudioObj, ResultCode>(result.ResultCode));
}
else
{
JsonWebRequest.Upload(result.ResultData.upload_url, stream, "file", "audio", (Action <JsonResponseData>)(uploadResult =>
{
if (!uploadResult.IsSucceeded)
{
callback(new BackendResult <AudioObj, ResultCode>(ResultCode.UploadingFailed));
}
else
{
UploadResponseData uploadResponseData = JsonConvert.DeserializeObject <UploadResponseData>(uploadResult.JsonString);
VKRequestsDispatcher.DispatchRequestToVK <AudioObj>("audio.save", new Dictionary <string, string>()
{
{
"server",
uploadResponseData.server
},
{
"audio",
uploadResponseData.audio
},
{
"hash",
uploadResponseData.hash
},
{
"artist",
artist
},
{
"title",
title
}
}, callback, null, false, true, new CancellationToken?(), null);
}
}), "track.mp3", progressCallback, cancellation);
}
}), (Func <string, VKClient.Common.Backend.DataObjects.UploadServerAddress>)null, false, true, new CancellationToken?(), null);
}
public static void Upload(string uri, Stream data, string paramName, string uploadContentType, Action <JsonResponseData> resultCallback, string fileName = null, Action <double> progressCallback = null, Cancellation c = null)
{
JsonWebRequest.RequestState rState = new JsonWebRequest.RequestState()
{
resultCallback = resultCallback
};
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.AllowWriteStreamBuffering = false;
request.UserAgent = AppInfo.AppVersionForUserAgent;
rState.request = request;
request.Method = "POST";
string str1 = string.Format("----------{0:N}", Guid.NewGuid());
string str2 = "multipart/form-data; boundary=" + str1;
request.ContentType = str2;
request.CookieContainer = new CookieContainer();
string header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"{1}\"; filename=\"{2}\";\r\nContent-Type: {3}\r\n\r\n", str1, paramName, (fileName ?? "myDataFile"), uploadContentType);
string footer = string.Format("\r\n--{0}--\r\n", str1);
request.ContentLength = ((long)Encoding.UTF8.GetByteCount(header) + data.Length + (long)Encoding.UTF8.GetByteCount(footer));
request.BeginGetRequestStream((AsyncCallback)(ar =>
{
try
{
Stream requestStream = request.EndGetRequestStream(ar);
requestStream.Write(Encoding.UTF8.GetBytes(header), 0, Encoding.UTF8.GetByteCount(header));
StreamUtils.CopyStream(data, requestStream, progressCallback, c, 0L);
requestStream.Write(Encoding.UTF8.GetBytes(footer), 0, Encoding.UTF8.GetByteCount(footer));
requestStream.Close();
request.BeginGetResponse(new AsyncCallback(JsonWebRequest.RespCallback), rState);
}
catch (Exception ex)
{
Logger.Instance.Error("Upload failed to write data to request stream.", ex);
JsonWebRequest.SafeClose(rState);
JsonWebRequest.SafeInvokeCallback(rState.resultCallback, false, null);
}
}), null);
}
catch (Exception ex)
{
Logger.Instance.Error("Upload failed.", ex);
JsonWebRequest.SafeClose(rState);
JsonWebRequest.SafeInvokeCallback(rState.resultCallback, false, null);
}
}
private static void RespCallback(IAsyncResult asynchronousResult)
{
JsonWebRequest.RequestState asyncState = (JsonWebRequest.RequestState)asynchronousResult.AsyncState;
try
{
HttpWebRequest request = asyncState.request;
asyncState.response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);
Stream compressedResponseStream = asyncState.response.GetCompressedResponseStream();
asyncState.streamResponse = compressedResponseStream;
compressedResponseStream.BeginRead(asyncState.BufferRead, 0, 5000, new AsyncCallback(JsonWebRequest.ReadCallBack), asyncState);
}
catch (WebException ex1)
{
Logger.Instance.Error(string.Format("RespCallback failed. Got httpWebResponse = {0} , uri = {1}", (ex1.Response is HttpWebResponse), ((WebRequest)asyncState.request).RequestUri), (Exception)ex1);
if (ex1.Response is HttpWebResponse && ex1.Response.ContentLength > 0L)
{
WebResponse response = ex1.Response;
asyncState.response = ex1.Response as HttpWebResponse;
try
{
Stream compressedResponseStream = asyncState.response.GetCompressedResponseStream();
asyncState.streamResponse = compressedResponseStream;
compressedResponseStream.BeginRead(asyncState.BufferRead, 0, 5000, new AsyncCallback(JsonWebRequest.ReadCallBack), asyncState);
}
catch (Exception ex2)
{
Logger.Instance.Error(string.Format("RespCallback failed. Uri ={0}", ((WebRequest)asyncState.request).RequestUri), ex2);
JsonWebRequest.SafeClose(asyncState);
JsonWebRequest.SafeInvokeCallback(asyncState.resultCallback, false, null);
}
}
else
{
JsonWebRequest.SafeClose(asyncState);
JsonWebRequest.SafeInvokeCallback(asyncState.resultCallback, false, null);
}
}
catch (Exception ex)
{
Logger.Instance.Error(string.Format("RespCallback failed. Uri ={0}", ((WebRequest)asyncState.request).RequestUri), ex);
JsonWebRequest.SafeClose(asyncState);
JsonWebRequest.SafeInvokeCallback(asyncState.resultCallback, false, null);
}
}
public static void Download(string uri, long fromByte, long toByte, Action <HttpStatusCode, long, byte[]> resultCallback)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
if (fromByte > 0L || toByte > 0L)
{
request.Headers["range"] = "bytes=" + fromByte + "-" + toByte;
}
request.BeginGetResponse((AsyncCallback)(asyncRes =>
{
byte[] numArray = (byte[])null;
HttpStatusCode httpStatusCode = HttpStatusCode.ServiceUnavailable;
long num = 0;
try
{
HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asyncRes);
httpStatusCode = response.StatusCode;
if (((IEnumerable <string>)response.Headers.AllKeys).Contains <string>("Content-Range"))
{
num = JsonWebRequest.ReadContentLengthFromHeaderValue(response.Headers["Content-Range"]);
}
using (Stream responseStream = ((WebResponse)response).GetResponseStream())
{
if (num == 0L)
{
num = responseStream.Length;
}
numArray = StreamUtils.ReadFullyToByteArray(responseStream);
}
}
catch (WebException ex)
{
if (ex.Response is HttpWebResponse)
{
httpStatusCode = (ex.Response as HttpWebResponse).StatusCode;
}
}
catch (Exception)
{
}
resultCallback(httpStatusCode, num, numArray);
}), null);
}
public static void SendHTTPRequestAsync(string uri, Action <JsonResponseData> resultCallback, Dictionary <string, object> postData = null)
{
Logger.Instance.Info("Starting GetJsonAsync for uri = {0}", uri);
Interlocked.Increment(ref JsonWebRequest._currentNumberOfRequests);
JsonWebRequest.RequestState myRequestState = new JsonWebRequest.RequestState();
try
{
myRequestState.resultCallback = resultCallback;
HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
myHttpWebRequest.UserAgent = AppInfo.AppVersionForUserAgent;
myRequestState.request = myHttpWebRequest;
if (postData != null)
{
string boundary = string.Format("----------{0:N}", Guid.NewGuid());
string str = "multipart/form-data; boundary=" + boundary;
byte[] formData = JsonWebRequest.GetMultipartFormData(postData, boundary);
myHttpWebRequest.Method = "POST";
myHttpWebRequest.ContentType = str;
myHttpWebRequest.CookieContainer = new CookieContainer();
myHttpWebRequest.BeginGetRequestStream((AsyncCallback)(ar =>
{
Stream requestStream = myHttpWebRequest.EndGetRequestStream(ar);
byte[] buffer = formData;
int offset = 0;
int length = formData.Length;
requestStream.Write(buffer, offset, length);
requestStream.Close();
myHttpWebRequest.BeginGetResponse(new AsyncCallback(JsonWebRequest.RespCallback), myRequestState);
}), null);
}
else
{
myHttpWebRequest.BeginGetResponse(new AsyncCallback(JsonWebRequest.RespCallback), myRequestState);
}
}
catch (Exception ex)
{
Logger.Instance.Error("GetJsonAsync failed.", ex);
JsonWebRequest.SafeClose(myRequestState);
JsonWebRequest.SafeInvokeCallback(myRequestState.resultCallback, false, null);
}
}
public void UploadProfilePhoto(byte[] photoData, Action <BackendResult <UploadPhotoResponseData, ResultCode> > callback)
{
this.GetPhotoUploadServer((Action <BackendResult <UploadServerAddress, ResultCode> >)(res =>
{
if (res.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <UploadPhotoResponseData, ResultCode>(res.ResultCode));
}
else
{
JsonWebRequest.Upload(res.ResultData.upload_url, (Stream) new MemoryStream(photoData), "photo", "image", (Action <JsonResponseData>)(jsonResult =>
{
if (!jsonResult.IsSucceeded)
{
callback(new BackendResult <UploadPhotoResponseData, ResultCode>(ResultCode.UnknownError));
}
else
{
callback(new BackendResult <UploadPhotoResponseData, ResultCode>(ResultCode.Succeeded, JsonConvert.DeserializeObject <UploadPhotoResponseData>(jsonResult.JsonString)));
}
}), "MyImage.jpg", null, null);
}
}));
}
public void UploadPhotoToWall(long userOrGroupId, bool isGroup, byte[] photoData, Action <BackendResult <Photo, ResultCode> > callback, Action <double> progressCallback = null, Cancellation c = null)
{
this.GetPhotoUploadServerWall(userOrGroupId, isGroup, (Action <BackendResult <UploadServerAddress, ResultCode> >)(getUplResp =>
{
if (getUplResp.ResultCode != ResultCode.Succeeded)
{
callback(new BackendResult <Photo, ResultCode>(getUplResp.ResultCode));
}
else
{
JsonWebRequest.Upload(getUplResp.ResultData.upload_url, (Stream) new MemoryStream(photoData), "file1", "image", (Action <JsonResponseData>)(jsonResult =>
{
if (!jsonResult.IsSucceeded)
{
callback(new BackendResult <Photo, ResultCode>(ResultCode.UnknownError));
}
else
{
this.SaveWallPhoto(userOrGroupId, isGroup, JsonConvert.DeserializeObject <UploadPhotoResponseData>(jsonResult.JsonString), callback);
}
}), "MyImage.jpg", progressCallback, c);
}
}));
}
private static void DoDispatch <R>(string baseUrl, string methodName, Dictionary <string, string> parameters, Action <BackendResult <R, ResultCode> > callback, Func <string, R> customDeserializationFunc = null, bool lowPriority = false, bool pageDataRequest = true, CancellationToken?cancellationToken = null, Action confirmationRequiredHandler = null)
{
parameters["v"] = VKConstants.API_VERSION;
if (!string.IsNullOrEmpty(VKRequestsDispatcher._autorizationData != null ? VKRequestsDispatcher._autorizationData.access_token : null))
{
parameters["access_token"] = VKRequestsDispatcher._autorizationData.access_token;
}
VKRequestsDispatcher.AddLangParameter(parameters);
if (!string.IsNullOrEmpty(VKRequestsDispatcher._autorizationData != null ? VKRequestsDispatcher._autorizationData.secret : null))
{
if (parameters.ContainsKey("sig"))
{
parameters.Remove("sig");
}
string str1 = JsonWebRequest.ConvertDictionaryToQueryString(parameters, false);
if (str1 != string.Empty)
{
str1 = "?" + str1;
}
string str2 = VKRequestsDispatcher.HashString("/method/" + methodName + str1 + VKRequestsDispatcher._autorizationData.secret);
parameters["sig"] = str2.ToLower();
}
JsonWebRequest.SendHTTPRequestAsync(!VKRequestsDispatcher.USE_HTTP ? "https://" + baseUrl : "http://" + baseUrl, parameters, (Action <JsonResponseData>)(jsonResp =>
{
BackendResult <R, ResultCode> backendResult = new BackendResult <R, ResultCode>(ResultCode.CommunicationFailed);
if (jsonResp.IsSucceeded)
{
VKRequestsDispatcher.ResultData resultFromJson = VKRequestsDispatcher.GetResultFromJson(JObject.Parse(jsonResp.JsonString));
backendResult.ResultCode = resultFromJson.ResultCode;
backendResult.Error = resultFromJson.error;
if (backendResult.ResultCode == ResultCode.UserAuthorizationFailed)
{
if (!string.IsNullOrEmpty(VKRequestsDispatcher._autorizationData != null ? VKRequestsDispatcher._autorizationData.access_token : null))
{
Logger.Instance.Error("RECEIVED AUTHORIZATION FAILURE!!! JSON STR = " + jsonResp.JsonString ?? "");
LogoutRequestHandler.InvokeLogoutRequest();
}
}
if (backendResult.ResultCode == ResultCode.CaptchaRequired)
{
CaptchaUserRequestHandler.InvokeCaptchaRequest(new CaptchaUserRequest()
{
CaptchaSid = resultFromJson.captcha_sid,
Url = resultFromJson.captcha_img
}, (Action <CaptchaUserResponse>)(captchaResp =>
{
if (!captchaResp.IsCancelled)
{
Dictionary <string, string> parameters1 = parameters;
parameters1["captcha_sid"] = captchaResp.Request.CaptchaSid;
parameters1["captcha_key"] = captchaResp.EnteredString;
VKRequestsDispatcher.DoDispatch <R>(baseUrl, methodName, parameters1, callback, customDeserializationFunc, lowPriority, pageDataRequest, cancellationToken, null);
}
else
{
VKRequestsDispatcher.InvokeCallback((Action)(() => callback(new BackendResult <R, ResultCode>(ResultCode.CaptchaControlCancelled))), cancellationToken);
}
}));
}
else if (backendResult.ResultCode == ResultCode.ValidationRequired)
{
if (resultFromJson.validation_type == "2fa_app" || resultFromJson.validation_type == "2fa_sms")
{
if (parameters.ContainsKey("force_sms") || parameters.ContainsKey("code"))
{
R r = customDeserializationFunc != null ? customDeserializationFunc("") : default(R);
VKRequestsDispatcher.InvokeCallback((Action)(() => callback(new BackendResult <R, ResultCode>(ResultCode.Succeeded, r))), cancellationToken);
}
else
{
CaptchaUserRequestHandler.InvokeValidation2FARequest(new Validation2FAUserRequest()
{
username = parameters.ContainsKey("username") ? parameters["username"] : "",
password = parameters.ContainsKey("password") ? parameters["password"] : "",
phoneMask = resultFromJson.phone_mask,
validationType = resultFromJson.validation_type,
validationSid = resultFromJson.validation_sid
}, (Action <ValidationUserResponse>)(valResp => VKRequestsDispatcher.ProcessValidationResponse <R>(valResp, baseUrl, methodName, parameters, callback, customDeserializationFunc, lowPriority, pageDataRequest, cancellationToken)));
}
}
else
{
CaptchaUserRequestHandler.InvokeValidationRequest(new ValidationUserRequest()
{
ValidationUri = resultFromJson.redirect_uri
}, (Action <ValidationUserResponse>)(valResp => VKRequestsDispatcher.ProcessValidationResponse <R>(valResp, baseUrl, methodName, parameters, callback, customDeserializationFunc, lowPriority, pageDataRequest, cancellationToken)));
}
}
else if (backendResult.ResultCode == ResultCode.ConfirmationRequired)
{
if (!VKRequestsDispatcher.GetIsResponseCancelled(cancellationToken))
{
Action action = confirmationRequiredHandler;
if (action != null)
{
action();
}
IBackendConfirmationHandler confirmationHandler = ServiceLocator.Resolve <IBackendConfirmationHandler>();
if (confirmationHandler != null)
{
confirmationHandler.Confirm(resultFromJson.confirmation_text, (Action <bool>)(confirmed =>
{
if (confirmed)
{
parameters["confirm"] = "1";
VKRequestsDispatcher.DoDispatch <R>(baseUrl, methodName, parameters, callback, customDeserializationFunc, lowPriority, pageDataRequest, cancellationToken, null);
}
else
{
VKRequestsDispatcher.InvokeCallback((Action)(() => callback(new BackendResult <R, ResultCode>(ResultCode.ConfirmationCancelled))), cancellationToken);
}
}));
}
}
}
else if (backendResult.ResultCode == ResultCode.NotEnoughMoney)
{
if (!VKRequestsDispatcher.GetIsResponseCancelled(cancellationToken))
{
IBackendNotEnoughMoneyHandler enoughMoneyHandler = ServiceLocator.Resolve <IBackendNotEnoughMoneyHandler>();
Action action1 = (() => VKRequestsDispatcher.DoDispatch <R>(baseUrl, methodName, parameters, callback, customDeserializationFunc, lowPriority, pageDataRequest, cancellationToken, null));
Action action2 = (Action)(() => VKRequestsDispatcher.InvokeCallback((Action)(() => callback(new BackendResult <R, ResultCode>(ResultCode.BalanceRefillCancelled))), cancellationToken));
if (enoughMoneyHandler != null)
{
Action refilledCallback = action1;
Action cancelledCallback = action2;
enoughMoneyHandler.RequestBalanceRefill(refilledCallback, cancelledCallback);
}
}
}
else if (backendResult.ResultCode == ResultCode.Succeeded)
{
try
{
List <ExecuteError> executeErrorList = null;
R r;
if (customDeserializationFunc != null)
{
r = customDeserializationFunc(jsonResp.JsonString);
}
else if (typeof(R) == typeof(VKClient.Common.Backend.DataObjects.ResponseWithId))
{
r = JsonConvert.DeserializeObject <R>(jsonResp.JsonString);
}
else
{
VKRequestsDispatcher.GenericRoot <R> genericRoot = JsonConvert.DeserializeObject <VKRequestsDispatcher.GenericRoot <R> >(jsonResp.JsonString);
r = genericRoot.response;
executeErrorList = genericRoot.execute_errors;
}
backendResult.ResultData = r;
backendResult.ExecuteErrors = executeErrorList;
}
catch (Exception ex)
{
Logger.Instance.Error("Error during deserialization", ex);
backendResult.ResultCode = ResultCode.DeserializationError;
}
}
}
if (backendResult.ResultCode == ResultCode.CaptchaRequired || backendResult.ResultCode == ResultCode.ValidationRequired || (backendResult.ResultCode == ResultCode.ConfirmationRequired || backendResult.ResultCode == ResultCode.NotEnoughMoney))
{
return;
}
VKRequestsDispatcher.InvokeCallback((Action)(() =>
{
Action <BackendResult <R, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <R, ResultCode> backendResult1 = backendResult;
action(backendResult1);
}), cancellationToken);
}), true, lowPriority, pageDataRequest);
}
public void ReverseGeocode(double latitude, double longitude, Action <BackendResult <GoogleGeocodeResponse, ResultCode> > callback)
{
JsonWebRequest.SendHTTPRequestAsync(string.Format(MapsService._reverseGeocodeUriFormat, this.CoordinatesToString(latitude, longitude), CultureInfo.CurrentCulture), (Action <JsonResponseData>)(data =>
{
if (!data.IsSucceeded)
{
callback(new BackendResult <GoogleGeocodeResponse, ResultCode>(ResultCode.CommunicationFailed));
}
else
{
GoogleGeocode googleGeocode = JsonConvert.DeserializeObject <GoogleGeocode>(data.JsonString);
if (googleGeocode.results != null && googleGeocode.results.Count > 0)
{
GoogleGeocodeResult googleGeocodeResult = googleGeocode.results.FirstOrDefault <GoogleGeocodeResult>((Func <GoogleGeocodeResult, bool>)(r =>
{
if (r.address_components != null)
{
return(r.address_components.Count > 0);
}
return(false);
}));
if (googleGeocodeResult != null)
{
List <GoogleAddressComponent> addressComponents = googleGeocodeResult.address_components;
string str1 = "";
string str2 = "";
string str3 = "";
string str4 = "";
string str5 = "";
foreach (GoogleAddressComponent addressComponent in addressComponents)
{
if (addressComponent.types != null && addressComponent.types.Count != 0)
{
List <string> types = addressComponent.types;
if (types.Contains("route") && string.IsNullOrEmpty(str1))
{
str1 = addressComponent.long_name;
}
else if (types.Contains("administrative_area_level_1") && string.IsNullOrEmpty(str2))
{
str2 = addressComponent.long_name;
}
else if (types.Contains("administrative_area_leve_2") && string.IsNullOrEmpty(str3))
{
str3 = addressComponent.long_name;
}
else if (types.Contains("country") && string.IsNullOrEmpty(str4))
{
str4 = addressComponent.long_name;
str5 = addressComponent.short_name;
}
}
}
callback(new BackendResult <GoogleGeocodeResponse, ResultCode>(ResultCode.Succeeded, new GoogleGeocodeResponse()
{
Route = str1,
AdministrativeArea1 = str2,
AdministrativeArea2 = str3,
Country = str4,
CountryISO = str5
}));
return;
}
}
callback(new BackendResult <GoogleGeocodeResponse, ResultCode>(ResultCode.UnknownError));
}
}), null);
}
