public override void ViewDidLoad ()
{
base.ViewDidLoad ();
var auth = new OAuth1Authenticator ("Ywun66NxYNMXgjzNRdIG12q4k",
"XQAQ5djSlMOiXfMhn5rl4fdPahqw0wNPW6nBS5I9aRCajbxMvJ",
new Uri("https://api.twitter.com/oauth/request_token"),
new Uri("https://api.twitter.com/oauth/authorize"),
new Uri("https://api.twitter.com/oauth/access_token"),
new Uri("http://mobile.twitter.com"));
auth.Completed += (sender, e) => {
DismissViewController (true, null);
if (e.IsAuthenticated) {
loggedInAccount = e.Account;
GetUserData ();
var mList = GetTwitterData();
mList.ContinueWith(async (Task<List<Status>> arg) =>{
myList = arg.Result;
//twitterHomeTableView.Source = new TwitterHomeSource(arg.Result.ToArray());
});
}
};
var ui = auth.GetUI();
PresentViewController(ui, true, null);
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
var auth = new OAuth1Authenticator ("Ywun66NxYNMXgjzNRdIG12q4k",
"XQAQ5djSlMOiXfMhn5rl4fdPahqw0wNPW6nBS5I9aRCajbxMvJ",
new Uri("https://api.twitter.com/oauth/request_token"),
new Uri("https://api.twitter.com/oauth/authorize"),
new Uri("https://api.twitter.com/oauth/access_token"),
new Uri("http://mobile.twitter.com"));
auth.Completed += (sender, e) => {
DismissViewController (true, null);
if (e.IsAuthenticated) {
loggedInAccount = e.Account;
GetUserData ();
var mList = GetTwitterData().ToString();
PresentViewController(new TwitterTimelineTabController(mList), true, null);
}
};
var ui = auth.GetUI();
PresentViewController(ui, true, null);
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
if (showLogin && App.User == null)
{
showLogin = false;
//Twitter with oauth1
var auth = new OAuth1Authenticator(
consumerKey: "Twitter Consumer Key",
consumerSecret: "Twitter Consumer Secret",
// the redirect URL for the service
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
// the auth URL for the service
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
// callback url must be to a page where the URL does not change during navigation
callbackUrl: new Uri("https://mobile.twitter.com")
);
auth.Completed += async (sender, eventArgs) =>
{
// DismissViewController(true, null);
await Element.Navigation.PopModalAsync();
if (eventArgs.IsAuthenticated)
{
App.User = new Entities.UserDetails();
// Use eventArgs.Account to do wonderful things
App.User.Token = eventArgs.Account.Properties["oauth_token"];
App.User.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.User.TwitterId = eventArgs.Account.Properties["user_id"];
App.User.ScreenName = eventArgs.Account.Properties["screen_name"];
//Store details for future use,
//so we don't have to promt authentication screen everytime
AccountStore.Create().Save(eventArgs.Account, "Twitter");
App.SuccessfulLoginAction.Invoke();
}
//else
//{
// // The user cancelled
//}
};
PresentViewController(auth.GetUI(), true, null);
}
}
protected override void OnElementPropertyChanged(object s, System.ComponentModel.PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(s, e);
var activity = this.Context as Activity;
if (showLogin && App.User == null)
{
showLogin = false;
//Twitter with oauth1
var auth = new OAuth1Authenticator(
consumerKey: "Twitter Consumer Key",
consumerSecret: "Twitter Consumer Secret",
// the redirect URL for the service
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
// the auth URL for the service
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
// callback url must be to a page where the URL does not change during navigation
callbackUrl: new Uri("https://mobile.twitter.com")
);
auth.Completed += async (sender, eventArgs) =>
{
await Element.Navigation.PopModalAsync();
if (eventArgs.IsAuthenticated)
{
App.User = new Entities.UserDetails();
// Use eventArgs.Account to do wonderful things
App.User.Token = eventArgs.Account.Properties["oauth_token"];
App.User.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.User.TwitterId = eventArgs.Account.Properties["user_id"];
App.User.ScreenName = eventArgs.Account.Properties["screen_name"];
App.SuccessfulLoginAction.Invoke();
}
//else
//{
// // The user cancelled
//}
};
activity.StartActivity(auth.GetUI(activity));
}
}
public void Ctor()
{
const string key = "key";
const string secret = "secret";
var authUri = new Uri ("http://xamarin.com/auth");
var requestTokenUri = new Uri ("http://xamarin.com/request");
var accessTokenUri = new Uri ("http://xamarin.com/access");
var callbackTokenUri = new Uri ("http://xamarin.com/callback");
var oauth = new OAuth1Authenticator (key, secret, requestTokenUri, authUri, accessTokenUri, callbackTokenUri);
Assert.That (oauth.ConsumerKey, Is.EqualTo (key));
Assert.That (oauth.ConsumerSecret, Is.EqualTo (secret));
Assert.That (oauth.AuthorizeUrl, Is.EqualTo (authUri));
Assert.That (oauth.RequestTokenUrl, Is.EqualTo (requestTokenUri));
Assert.That (oauth.AccessTokenUrl, Is.EqualTo (accessTokenUri));
Assert.That (oauth.CallbackUrl, Is.EqualTo (callbackTokenUri));
}
public void Can_Authenticate_Twitter()
{
// To pass this test, place a file config.json in the RestSharp.IntegrationTests folder
// with the following content:
//
// {
// "ConsumerKey": "",
// "ConsumerSecret": "",
// "AccessToken": "",
// "AccessSecret": ""
// }
//
// The tokens can be found on the "Keys and Access Tokens" tab on the application
// management page for your app: https://apps.twitter.com/
Assert.True(File.Exists(@"..\..\config.json"));
if (!(SimpleJson.SimpleJson.DeserializeObject(File.ReadAllText(@"..\..\config.json")) is JsonObject config)
)
{
return;
}
var client = new RestClient("https://api.twitter.com/1.1")
{
Authenticator = OAuth1Authenticator.ForProtectedResource(
(string)config["ConsumerKey"],
(string)config["ConsumerSecret"],
(string)config["AccessToken"],
(string)config["AccessSecret"])
};
var request = new RestRequest("account/verify_credentials.json");
request.AddParameter("include_entities", "true", ParameterType.QueryString);
var response = client.Execute(request);
Assert.NotNull(response);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public List <Semester> GetUserCoursesAsLecturer(string accessToken, string tokenSecret, User user)
{
Client.Authenticator = OAuth1Authenticator
.ForProtectedResource(ConsumerKey, ConsumerSecret, accessToken, tokenSecret);
var groupsRequest = new RestRequest("groups/lecturer", Method.GET);
groupsRequest.AddParameter("fields", "course_id|course_name|lecturers");
var groupsResponse = Client.Execute(groupsRequest);
JObject json = JObject.Parse(groupsResponse.Content);
var semesters = new List <Semester>();
foreach (var semJson in json["groups"].Children())
{
var semester = new Semester()
{
Name = semJson.ToObject <JProperty>().Name
};
semester.Courses = new List <Course>();
foreach (var courseJson in semJson.First.Children())
{
var course = new Course()
{
Name = courseJson.Value <string>("course_id")
};
course.CourseLecturers = new List <CourseLecturer>()
{
new CourseLecturer()
{
LecturerId = user.Id.Value
}
};
semester.Courses.Add(course);
}
semesters.Add(semester);
}
return(semesters);
}
internal IRestResponse <T> ExecuteRequest(IRestRequest request)
{
var client = new RestSharp.RestClient(_baseUrl);
client.FollowRedirects = false;
if (_ticket != null)
{
client.Authenticator = OAuth1Authenticator.ForProtectedResource(_ticket.ConsumerKey, _ticket.ConsumerSecret, _ticket.AccessToken, _ticket.AccessTokenSecret);
}
var response = client.Execute <T>(request);
if ((int)response.StatusCode >= 400)
{
throw new ApiAccessException(response.Content)
{
StatusCode = response.StatusCode,
StatusDescription = response.StatusDescription,
RequestUrl = response.ResponseUri.AbsoluteUri
};
}
if ((int)response.StatusCode >= 300)
{
var location = response.Headers.SingleOrDefault(x => x.Name == "Location");
if (location != null)
{
request = CreateRestRequest(Method.GET, location.Value.ToString().Substring(_baseUrl.Length));
response = ExecuteRequest(request);
}
}
if (!string.IsNullOrEmpty(response.ErrorMessage))
{
throw new ApiAccessException(response.ErrorMessage);
}
return(response);
}
protected override void OnElementPropertyChanged(object s, System.ComponentModel.PropertyChangedEventArgs e)
{
base.OnElementPropertyChanged(s, e);
var activity = Context as Activity;
if (showLogin && App.User == null)
{
showLogin = false;
var auth = new OAuth1Authenticator(
consumerKey: "IPDotz1tp4c07AZywLUbUOBza",
consumerSecret: "FiGWZSvk1TIlK7XMYTpmacToPBNp8F32j4cT2RYsXRwaMe5q9S",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("https://www.facebook.com/connect/login_success.html")
);
auth.Completed += (sender, eventArgs) =>
{
if (eventArgs.IsAuthenticated)
{
App.User = new Model.UserDetails();
App.User.Token = eventArgs.Account.Properties["oauth_token"];
App.User.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.User.TwitterId = eventArgs.Account.Properties["user_id"];
App.User.ScreenName = eventArgs.Account.Properties["screen_name"];
App.SuccessfulLoginAction.Invoke();
}
else
{
}
};
activity.StartActivity(auth.GetUI(activity));
}
}
public OAuthToken RenewAccessToken(OAuthToken accessToken)
{
var client = new RestClient(_baseUrl)
{
Authenticator =
OAuth1Authenticator.ForAccessTokenRefresh(ConsumerKey, ConsumerSecret.To <string>(), accessToken.Token, accessToken.Secret, null)
};
var response = ExecuteRequest(client, new RestRequest("oauth/renew_access_token"));
if (response.ResponseStatus != ResponseStatus.Completed || response.StatusCode != HttpStatusCode.OK)
{
throw new ETradeAuthorizationRenewFailed(
LocalizedStrings.Str3349Params.Put(response.StatusCode + ": " + response.StatusDescription));
}
var qs = HttpUtility.ParseQueryString(response.Content);
var newToken = qs["oauth_token"];
return(newToken == null ? accessToken : new OAuthToken(ConsumerKey, newToken, qs["oauth_token_secret"]));
}
private static string POST(string json)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
//KEYS
const string consumerKey = "f705c6b2a43a7acfe9e6dda2a24389b139daab3195c6eb6418031c44e5c465ab";
const string consumerSecret = "10e254e3158b31eea1e3f8034cbe0a3c3c0c4553639a8b81047e55afb06c8f83";
const string accessToken = "62e84ef0542bdaf8343b469d9c703c59007577659be31a6b48928aed9132ea8a";
const string tokenSecret = "3157071cdee78d4a438c062db9b8134d0da1ffb376957e7e8c3b6bfeec4b248d";
//Endereço base
const string baseUrl = "https://5022901.restlets.api.netsuite.com/app/site/hosting/restlet.nl";
//criando a chamada com seus parametros
var client = new RestClient(baseUrl);
client.AddDefaultQueryParameter("script", "463");
client.AddDefaultQueryParameter("deploy", "1");
var request = new RestRequest(Method.POST);
//Parametros
request.AddHeader("Content-Type", "application/json");
request.AddParameter("cobranca", json, ParameterType.RequestBody);//tanto faz o primeiro campo, é só para identificar
//usando as chaves para criar o authorization
OAuth1Authenticator auth = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, accessToken, tokenSecret);
auth.SignatureMethod = OAuthSignatureMethod.HmacSha1;
auth.Realm = "5022901";
auth.ParameterHandling = OAuthParameterHandling.HttpAuthorizationHeader;
client.Authenticator = auth;
//chamada da api
IRestResponse response = client.Execute(request);
return(response.Content);
}
/// <summary>
/// the response for the new ticket request
/// </summary>
/// <param name="subdomain">the site's subdomain</param>
/// <param name="consumerKey">your consumerKey</param>
/// <param name="consumerSecret">your conumserSecret</param>
/// <param name="accessToken">the user's access token</param>
/// <param name="accessTokenSecret">the user's access token secret</param>
/// <param name="ticketId">the ticket id this message belongs to</param>
/// <param name="message">the ticket message</param>
/// <returns>the server resopnse for the new ticket message request</returns>
private async Task <IRestResponse> CreateNewTicketMessageResponse(string subdomain, string consumerKey, string consumerSecret, string accessToken, string accessTokenSecret, int ticketId, string message)
{
_client.BaseUrl = new Uri(string.Format("https://{0}.uservoice.com/api/v1/tickets/{1}", subdomain, ticketId));
_client.Authenticator = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, accessToken, accessTokenSecret);
RestRequest request = new RestRequest("ticket_messages.json", HttpMethod.Post);
request.AddHeader("If-Modified-Since", DateTime.Now.ToUniversalTime().ToString("R"));
var newmsg = new NewTicketMessage
{
NewMessage = new NewTicketMessage.TicketMessage()
{
MessageText = message
}
};
request.AddJsonBody(newmsg);
return(await _client.Execute(request));
}
/// <summary>
/// Initializes a new instance of the <see cref="GoodreadsClient"/> class.
/// Use this constructor if you already have OAuth permissions for the user.
/// </summary>
/// <param name="apiKey">Your Goodreads API key.</param>
/// <param name="apiSecret">Your Goodreads API secret.</param>
/// <param name="accessToken">The user's OAuth access token.</param>
/// <param name="accessSecret">The user's OAuth access secret.</param>
public GoodreadsClient(string apiKey, string apiSecret, string accessToken, string accessSecret)
{
var client = new RestClient(new Uri(GoodreadsUrl))
{
UserAgent = "goodreads-dotnet"
};
client.AddDefaultParameter("key", apiKey, ParameterType.QueryString);
client.AddDefaultParameter("format", "xml", ParameterType.QueryString);
var apiCredentials = new ApiCredentials(client, apiKey, apiSecret, accessToken, accessSecret);
// Setup the OAuth authenticator if they have passed on the appropriate tokens
if (!string.IsNullOrWhiteSpace(accessToken) &&
!string.IsNullOrWhiteSpace(accessSecret))
{
client.Authenticator = OAuth1Authenticator.ForProtectedResource(
apiKey, apiSecret, accessToken, accessSecret);
}
Connection = new Connection(client, apiCredentials);
Authors = new AuthorsClient(Connection);
Books = new BooksClient(Connection);
Shelves = new ShelvesClient(Connection);
Users = new UsersClient(Connection);
Reviews = new ReviewsClient(Connection);
Series = new SeriesClient(Connection);
AuthorsFollowing = new AuthorsFollowingClient(Connection);
Events = new EventsClient(Connection);
Followers = new FollowersClient(Connection);
Friends = new FriendsClient(Connection);
Notifications = new NotificationsClient(Connection);
Groups = new GroupClient(Connection);
Quotes = new QuotesClient(Connection);
UserStatuses = new UserStatusesClient(Connection);
Updates = new UpdatesClient(Connection);
Recommendations = new RecommendationsClient(Connection);
ReadStatuses = new ReadStatusesClient(Connection);
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear (animated);
if (App.IsLoggedIn)
return;
var auth = new OAuth1Authenticator(
consumerKey: App.Constants.consumerKey,
consumerSecret: App.Constants.consumerSecret,
requestTokenUrl: App.Constants.requestTokenUrl(),
authorizeUrl: App.Constants.authorizeUrl(),
accessTokenUrl: App.Constants.accessTokenUrl(),
callbackUrl: App.Constants.callbackUrl()
);
auth.Title = "Login with Twitter";
auth.BrowsingCompleted += (sender, e) => {
Console.WriteLine("browsing completed");
};
auth.Error += (sender, e) => {
Console.WriteLine("There was an error {0}",e.Message);
};
auth.Completed += (sender, e) => {
Console.WriteLine ("Inside completed");
DismissViewController(true, null);
if (e.IsAuthenticated) {
App.User = new TwitterUser();
var properties = e.Account.Properties;
App.User.Token = e.Account.Properties["oauth_token"];
App.User.TokenSecret = e.Account.Properties["oauth_token_secret"];
App.User.TwitterId = e.Account.Properties["user_id"];
App.User.Name = e.Account.Properties["screen_name"];
App.SuccessfulLoginAction.Invoke();
}
};
PresentViewController (auth.GetUI (), true, null);
}
public EtsyReceipt GetReceipts()
{
string baseUrl = "https://openapi.etsy.com/v2/shops/21594656/";
string consumerKey = "u4zj4e4jcakajf2wtanvtljn";
string consumerSecret = "k51t6ib8jq";
string oAuthToken = "c0cd1745bc4f14b6a268ee88c45fe9";
string oAuthSecret = "420e7bbf0d";
var etsyRestClient = new RestClient(baseUrl)
{
Authenticator = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, oAuthToken, oAuthSecret)
};
var request = new RestRequest("receipts", Method.GET);
request.AddParameter("limit", "1000");
IRestResponse <EtsyReceipt> response = etsyRestClient.Execute <EtsyReceipt>(request);
return(response.Data);
}
private static IRestClient CreateClient(ApiCredentials credentials)
{
var client = new RestClient(new Uri(GoodreadsUrl))
{
UserAgent = GoodreadsUserAgent
};
client.AddDefaultParameter("key", credentials.ApiKey, ParameterType.QueryString);
client.AddDefaultParameter("format", "xml", ParameterType.QueryString);
if (!string.IsNullOrEmpty(credentials.OAuthToken) && !string.IsNullOrEmpty(credentials.OAuthTokenSecret))
{
client.Authenticator =
OAuth1Authenticator.ForProtectedResource(
credentials.ApiKey,
credentials.ApiSecret,
credentials.OAuthToken,
credentials.OAuthTokenSecret);
}
return(client);
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
this.NavigationItem.Title = "Home";
var auth = new OAuth1Authenticator ("Ywun66NxYNMXgjzNRdIG12q4k",
"XQAQ5djSlMOiXfMhn5rl4fdPahqw0wNPW6nBS5I9aRCajbxMvJ",
new Uri("https://api.twitter.com/oauth/request_token"),
new Uri("https://api.twitter.com/oauth/authorize"),
new Uri("https://api.twitter.com/oauth/access_token"),
new Uri("http://mobile.twitter.com"));
auth.Completed += (sender, e) => {
DismissViewController (true, null);
if (e.IsAuthenticated) {
loggedInAccount = e.Account;
GetUserData ();
var mList = GetTwitterData();
TableView.RowHeight = UITableView.AutomaticDimension;
TableView.EstimatedRowHeight = 160;
TableView.Source = new TwitterHomeSource(mList.ToArray());
//twitterHomeTableView.ReloadData();
}
};
var ui = auth.GetUI();
PresentViewController(ui, true, null);
}
public static IRestResponse ExchangeRequestToken(OAuthTicket ticket, string baseurl, string accessTokenUrl, string additionalParamters = null)
{
var restClient = new RestSharp.RestClient(baseurl);
restClient.Authenticator = OAuth1Authenticator.ForAccessToken(ticket.ConsumerKey, ticket.ConsumerSecret, ticket.AccessToken, ticket.AccessTokenSecret);
var request = new RestRequest(accessTokenUrl, Method.POST);
string[] additionParms = additionalParamters.Split('&');
foreach (var current in additionParms)
{
string[] nameValue = current.Split('=');
if (nameValue.Length == 2)
{
request.AddParameter(nameValue[0], nameValue[1]);
}
}
var response = restClient.Execute(request);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApiAccessException(response.StatusDescription)
{
StatusCode = response.StatusCode,
StatusDescription = response.StatusDescription,
RequestUrl = response.ResponseUri.AbsoluteUri
};
}
else
{
var qs = RestSharp.Extensions.MonoHttp.HttpUtility.ParseQueryString(response.Content);
ticket.AccessToken = qs["oauth_token"];
ticket.AccessTokenSecret = qs["oauth_token_secret"];
return(response);
}
}
/// <summary>
/// Queries user info using corresponding service and data received by access token request.
/// </summary>
/// <returns>The task that queries the user information and the string that was returned by the query</returns>
private async Task <string> QueryUserInfo()
{
var client = _factory.CreateClient(UserInfoServiceEndpoint);
client.Authenticator = OAuth1Authenticator.ForProtectedResource(
Configuration.ClientId,
Configuration.ClientSecret,
AccessToken,
AccessTokenSecret);
var request = _factory.CreateRequest(UserInfoServiceEndpoint);
BeforeGetUserInfo(
new BeforeAfterRequestArgs
{
Client = client,
Request = request,
Configuration = Configuration
});
return((await client.ExecuteAndVerify(request).ConfigureAwait(false)).Content);
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
if (showLogin && App.User == null)
{
//Twitter with OAuth1
var auth = new OAuth1Authenticator(
consumerKey: "Add your consumer key from Twitter",
consumerSecret: "Add your consumer secrete from Twitter",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("http://twitter.com")
);
auth.Completed += (sender, eventArgs) =>
{
DismissViewController(true, null);
if (eventArgs.IsAuthenticated)
{
App.User = new Entities.UserDetails();
App.User.Token = eventArgs.Account.Properties["oauth_token"];
App.User.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.User.TwitterId = eventArgs.Account.Properties["user_id"];
App.User.Name = eventArgs.Account.Properties["screen_name"];
//Store details for future use,
//so we don't have to prompt authentication screen everytime
AccountStore.Create().Save(eventArgs.Account, "Twitter");
App.SuccessfulLoginAction.Invoke();
}
};
PresentViewController(auth.GetUI(), true, null);
}
}
/// <summary>
/// Gets the group types.
/// </summary>
/// <returns></returns>
public override List <GroupType> GetGroupTypes()
{
List <GroupType> groupTypes = new List <GroupType>();
try
{
_client.Authenticator = OAuth1Authenticator.ForProtectedResource(ApiConsumerKey, ApiConsumerSecret, OAuthToken, OAuthSecret);
_request = new RestRequest(API_GROUP_TYPES, Method.GET);
_request.AddHeader("content-type", "application/xml");
var response = _client.Execute(_request);
ApiCounter++;
XDocument xdoc = XDocument.Parse(response.Content);
if (F1Api.DumpResponseToXmlFile)
{
xdoc.Save(Path.Combine(ImportPackage.PackageDirectory, $"API_GROUP_TYPES_ResponseLog.xml"));
}
var sourceGroupTypes = xdoc.Element("groupTypes");
foreach (var sourceGroupType in sourceGroupTypes.Elements())
{
var groupType = new GroupType();
groupType.Id = sourceGroupType.Attribute("id").Value.AsInteger();
groupType.Name = sourceGroupType.Element("name")?.Value;
groupTypes.Add(groupType);
}
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
}
return(groupTypes);
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
if (showLogin && App.UserInfo == null)
{
//Twitter with OAuth1
var auth = new OAuth1Authenticator(
consumerKey: "rsrleZR4jRNIN0Cm7uPGxOpWy",
consumerSecret: "ij1N7CcRwPtbe76RFdon8ruCJEMNVFJ4n03AKbVDMjzAFqbPqs",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("http://mobile.twitter.com")
);
auth.Completed += (sender, eventArgs) =>
{
DismissViewController(true, null);
if (eventArgs.IsAuthenticated)
{
App.UserInfo = new User();
App.UserInfo.Token = eventArgs.Account.Properties["oauth_token"];
App.UserInfo.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.UserInfo.TwitterId = eventArgs.Account.Properties["user_id"];
App.UserInfo.Name = eventArgs.Account.Properties["screen_name"];
//Store details for future use,
//so we don't have to prompt authentication screen everytime
AccountStore.Create().Save(eventArgs.Account, "Twitter");
App.SuccessfulLoginAction.Invoke();
}
};
PresentViewController(auth.GetUI(), true, null);
}
}
/* step two: exchange temp token for permanent one, updateand returns the UserCredentials */
public UserCredentials ProcessApprovedAuthCallback(string TempAuthToken, string UserId)
{
var baseUrl = this.BaseUrl;
var client = new RestClient(baseUrl);
var request = new RestRequest("account/access_token", Method.POST);
client.Authenticator = OAuth1Authenticator.ForAccessToken(
this.ConsumerKey, this.ConsumerSecret, TempAuthToken, UserCredentials.OauthTokenSecret);
var response = client.Execute(request);
var qs = HttpUtility.ParseQueryString(response.Content);
var oauth_token = qs["oauth_token"];
var oauth_token_secret = qs["oauth_token_secret"];
UserCredentials.OauthToken = oauth_token;
UserCredentials.OauthTokenSecret = oauth_token_secret;
UserCredentials.UserId = UserId;
return(UserCredentials);
}
/// <summary>
/// Connects the specified host name.
/// </summary>
/// <param name="hostName">Name of the host.</param>
/// <param name="apiUsername">The API username.</param>
/// <param name="apiPassword">The API password.</param>
public static void Connect(string hostName, string apiConsumerKey, string apiConsumerSecret, string apiUsername, string apiPassword)
{
Hostname = hostName;
ApiConsumerKey = apiConsumerKey;
ApiConsumerSecret = apiConsumerSecret;
ApiUsername = apiUsername;
ApiPassword = apiPassword;
_client = new RestClient(ApiUrl);
_client.Authenticator = OAuth1Authenticator.ForRequestToken(ApiConsumerKey, ApiConsumerSecret);
_request = new RestRequest(API_ACCESS_TOKEN, Method.POST);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
// hash the username/password and add it to the body of the request
var loginBytes = System.Text.Encoding.UTF8.GetBytes(apiUsername + " " + apiPassword);
var loginHash = Convert.ToBase64String(loginBytes);
_request.AddParameter("ec", loginHash, ParameterType.RequestBody);
// getting the api status sets the IsConnect flag
UpdateApiStatus();
}
public async Task <Uri> GetAuthorizationUri(string applicationName, Scope scope, Expiration expiration, Uri callbackUri = null)
{
callbackUri = callbackUri ?? new Uri("http://localhost/oauthcallback", UriKind.Absolute);
Authenticator = OAuth1Authenticator.ForRequestToken(_publicKey, _privateKey, callbackUri.AbsoluteUri);
var result = await RequestAsync(new RestRequest("OAuthGetRequestToken"));
var query = result.Content.ParseQueryString();
_requestToken = BuildOAuthToken(query);
if (_requestToken == null)
{
return(null);
}
return(BuildUri(new RestRequest("OAuthAuthorizeToken")
.AddParameter("oauth_token", _requestToken.Key)
.AddParameter("name", applicationName)
.AddParameter("scope", scope.ToScopeString())
.AddParameter("expiration", expiration.ToExpirationString())));
}
public bool SetAccessToken(EtOAuthConfig config, string verification)
{
var baseUrl = new Uri(config.TokenUrl);
var client = new RestClient(baseUrl)
{
Authenticator = OAuth1Authenticator.ForAccessToken(config.ConsumerKey, config.ConsumerSecret, config.OauthToken,
config.OauthTokenSecret, verification)
};
var requestAccessTokenRequest = new RestRequest("/oauth/access_token");
var requestActionTokenResponse = client.Execute(requestAccessTokenRequest);
var requestActionTokenResponseParameters = HttpUtility.ParseQueryString(requestActionTokenResponse.Content);
var accessToken = requestActionTokenResponseParameters["oauth_token"];
var accessSecret = requestActionTokenResponseParameters["oauth_token_secret"];
config.AccessSecret = accessSecret;
config.AccessToken = accessToken;
return(accessToken != string.Empty);
}
public static GetUser Do(int reff)
{
var client = new RestClient(url);
client.Authenticator = OAuth1Authenticator.ForProtectedResource(consumer_key, consumer_secret, token, token_secret);
var request = new RestRequest("/users/" + reff.ToString(), Method.GET);
//request.AddParameter("limit", "1", ParameterType.GetOrPost);
// request.AddParameter("category", "all",ParameterType.GetOrPost);
var response = client.Execute(request);
if (response != null && !string.IsNullOrWhiteSpace(response.Content))
{
string str = response.Content;
Base.str = str;
var serializer = new JavaScriptSerializer();
var ret = serializer.Deserialize <GetUser>(str);
return(ret);
}
return(null);
}
/// <summary>
/// Get temporary oauth_token and oauth_secret from twitter API.
/// Doc: https://developer.twitter.com/en/docs/basics/authentication/api-reference/request_token
/// </summary>
/// <param name="appKey">App customer key</param>
/// <param name="appSecretKey">App customer secret key</param>
/// <param name="callBackUrl">URL to redirect after get authentication token and token secret</param>
/// <returns>OAuthTokenData object with authentication tokens information</returns>
public RequestTokenResponseData GetRequestToken(string appKey, string appSecretKey, string callBackUrl)
{
var client = new RestClient(BaseUrl)
{
Authenticator = OAuth1Authenticator.ForRequestToken(appKey, appSecretKey, callBackUrl)
};
var request = new RestRequest("/oauth/request_token", Method.POST);
var response = client.Execute(request);
var queryString = HttpUtility.ParseQueryString(response.Content);
if (response.IsSuccessful)
{
return(new RequestTokenResponseData(queryString["oauth_token"],
queryString["oauth_token_secret"],
bool.TryParse(queryString["oauth_callback_confirmed"], out _)));
}
throw new CouldNotConnectException(
$"Error while connecting to Twitter Api when requesting token. Twitter EndPoint: /oauth/request_token.\n {response.Content}", response.StatusCode);
}
/// <summary>
/// request all suggestions in a forum
/// </summary>
/// <param name="subdomain">the site's subdomain</param>
/// <param name="forumId">the forumId</param>
/// <param name="consumerKey">your conusmer key</param>
/// <param name="consumerSecret">your consumer secret</param>
/// <param name="page">the result's page</param>
/// <param name="perPage">number of entries per page</param>
/// <param name="sort">the status used to order results</param>
/// <returns>the response for the request of all suggestions in a forum</returns>
private async Task <IRestResponse> GetAllSuggestionsResponse(string subdomain, string consumerKey, string consumerSecret, int forumId, int page = 1, int perPage = 10, SuggestionSort sort = SuggestionSort.newest, SuggestionFilter filter = SuggestionFilter.all, SuggestionStatusesResult.Status status = null)
{
_client = new RestClient(string.Format("https://{0}.uservoice.com/api/v1/forums/{1}/", subdomain, forumId));
_client.Authenticator = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, null, null);
RestRequest request = new RestRequest("suggestions.json", HttpMethod.Get);
request.AddHeader("If-Modified-Since", DateTime.Now.ToUniversalTime().ToString("R"));
request.AddParameter("sort", sort);
request.AddParameter("filter", filter);
if (status != null && status.id != 0)
{
request.AddParameter("status_id", status.id);
}
request.AddParameter("page", page);
request.AddParameter("per_page", perPage);
return(await _client.Execute(request));
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
if (showLogin && App.UserInfo == null)
{
//Twitter with OAuth1
var auth = new OAuth1Authenticator(
consumerKey: "rsrleZR4jRNIN0Cm7uPGxOpWy",
consumerSecret: "ij1N7CcRwPtbe76RFdon8ruCJEMNVFJ4n03AKbVDMjzAFqbPqs",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("http://mobile.twitter.com")
);
auth.Completed += (sender, eventArgs) =>
{
DismissViewController(true, null);
if (eventArgs.IsAuthenticated)
{
App.UserInfo = new User();
App.UserInfo.Token = eventArgs.Account.Properties["oauth_token"];
App.UserInfo.TokenSecret = eventArgs.Account.Properties["oauth_token_secret"];
App.UserInfo.TwitterId = eventArgs.Account.Properties["user_id"];
App.UserInfo.Name = eventArgs.Account.Properties["screen_name"];
//Store details for future use,
//so we don't have to prompt authentication screen everytime
AccountStore.Create().Save(eventArgs.Account, "Twitter");
App.SuccessfulLoginAction.Invoke();
}
};
PresentViewController(auth.GetUI(), true, null);
}
}
public static GetSites Do(string domain = "", int?limit = 0, int?offset = 0, bool?deleted = null)
{
var client = new RestClient(url);
client.Authenticator = OAuth1Authenticator.ForProtectedResource(consumer_key, consumer_secret, token, token_secret);
var request = new RestRequest("/sites", Method.GET);
request.AddParameter("brandRef", 1, ParameterType.GetOrPost);
if (!string.IsNullOrWhiteSpace(domain))
{
request.AddParameter("domain", domain, ParameterType.GetOrPost);
}
if (limit != 0)
{
request.AddParameter("limit", limit, ParameterType.GetOrPost);
}
if (offset != 0)
{
request.AddParameter("offset", offset, ParameterType.GetOrPost);
}
if (deleted != null)
{
request.AddParameter("deleted", deleted == true ? 1 : 0, ParameterType.GetOrPost);
}
var response = client.Execute(request);
if (response != null && !string.IsNullOrWhiteSpace(response.Content))
{
string str = response.Content;
Base.str = str;
var serializer = new JavaScriptSerializer();
var ret = serializer.Deserialize <GetSites>(str);
return(ret);
}
return(null);
}
/// <summary>
/// WITH IMAGE & TEXT.
/// Posts a tweet.
/// </summary>
/// <param name="token"></param>
/// <param name="imageBinary"></param>
/// <param name="textContent"></param>
/// <returns></returns>
public TwitterAPIResult <Tweet> PostTweet(OAuthv1AccessToken token, byte[] imageBinary, string textContent)
{
var media = UploadImage(token, imageBinary);
if (!media.IsSuccessful)
{
return(TwitterAPIResult <Tweet> .Fail("An error has occured when trying to upload media. Details: " + media.Message));
}
var _twitterRestClient = new RestClient("https://api.twitter.com/1.1/statuses/update.json")
{
Authenticator = OAuth1Authenticator
.ForProtectedResource(ConsumerKey, ConsumerSecret, token.OAuthToken, token.OAuthSecret)
};
var request = new RestRequest(Method.POST);
request.AddParameter("status", textContent);
request.AddParameter("media_ids", media.Entity.MediaId);
try
{
var response = _twitterRestClient.Execute(request);
if (!response.IsSuccessful)
{
return(TwitterAPIResult <Tweet> .Fail(response.Content));
}
var entity = JsonConvert.DeserializeObject <Tweet>(response.Content);
return(TwitterAPIResult <Entities.Tweet> .Success(entity));
}
catch (Exception ex)
{
return(TwitterAPIResult <Entities.Tweet> .Fail(ex.Message));
}
}
/// <summary>
/// Unlikes a resource
/// </summary>
/// <param name="type"></param>
/// <param name="filter"></param>
/// <param name="maxUpdates"></param>
public async Task <String> UnlikeResource(string resourceId, string resourceType)
{
client.Authenticator = OAuth1Authenticator.ForProtectedResource(API_KEY, OAUTH_SECRET, UserSettings.Settings.OAuthAccessToken, UserSettings.Settings.OAuthAccessTokenSecret);
await apiSemaphore.WaitAsync();
var request = new RestRequest("rating", Method.POST);
request.RequestFormat = DataFormat.Xml;
request.AddParameter("rating[rating]", 1);
request.AddParameter("rating[resource_id]", resourceId);
request.AddParameter("rating[resource_type]", resourceType);
var response = await client.ExecuteAsync(request);
ApiCooldown();
//TODO: This is a quick workaround
if (response.StatusCode == 201 && response.StatusDescription == "Created" && response.ResponseStatus == ResponseStatus.Completed)
{
var result = response.Content.ToString();
var start = result.IndexOf("<id type=\"integer\">") + 19;
var end = result.IndexOf("</id>", start);
string id = result.Substring(start, end - start);
//var status = DeserializeResponse<UserStatus>(response.Content.ToString());
//return status;
return(id);
}
else
{
return(String.Empty);
}
//else
// return false;
}
public override void ViewDidAppear(bool animated)
{
base.ViewDidAppear(animated);
if (done)
{
return;
}
var authTwitter = new OAuth1Authenticator(
consumerKey: "pHX7RNbyU0qySDfM3XGVXAo5Z",
consumerSecret: "s2k3jVdbVMGBEUEVsvJ1Hzgc0K7RpkUoabESrob5VNDECJy2zj",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("http://www.devenvexe.com"));
authTwitter.Completed += async(sender, eventArgs) =>
{
DismissViewController(true, null);
App.HideLoginView();
if (eventArgs.IsAuthenticated)
{
var accessToken = eventArgs.Account.Properties["access_token"].ToString();
var profile = await GetFacebookProfileAsync(accessToken);
await App.NavigateToProfile(profile);
}
else
{
await App.NavigateToProfile(null);
}
};
done = true;
PresentViewController(authTwitter.GetUI(), true, null);
}
public static async Task <List <string> > GetTweetsAsync(string tweet, int count, string twitterConsumerKey, string twitterConsumerSecret, string twitterAccessToken, string twitterAccessTokenSecret)
{
List <string> tweets = new List <string>();
var request = new RestRequest("1.1/search/tweets.json", Method.GET);
request.AddQueryParameter("q", tweet);
request.AddQueryParameter("result_type", "mixed");//recent popular mixed
request.AddQueryParameter("count", count.ToString());
request.AddQueryParameter("lang", "en");
var client = new RestClient("https://api.twitter.com")
{
Authenticator = OAuth1Authenticator.ForProtectedResource(
twitterConsumerKey,
twitterConsumerSecret,
twitterAccessToken,
twitterAccessTokenSecret)
};
var cancellationTokenSource = new CancellationTokenSource();
IRestResponse response = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token);
var content = response.Content; // raw content as string
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
return(null);
}
dynamic stuff = JsonConvert.DeserializeObject(content);
foreach (JObject item in stuff["statuses"])
{
tweets.Add(Sanitize(item["text"].ToString(), tweet));
}
return(tweets);
}
//
public async Task <bool> AutoLoginTwitter(LoginPageViewModel loginViewModel)
{
var account = AccountStore.Create().FindAccountsForService(AccountServiceTwitter).FirstOrDefault();
if (account != null)
{
await FetchTwitterData(account, loginViewModel);
return(true);
}
var authenticator = new OAuth1Authenticator("FWinTbxeDRfqL6pd6TyvBWqvY",
"vqHOpCafR8eNNy140xfNRy80W2zyN0A4whM9lcVWj9oSPalDAz",
new Uri("https://api.twitter.com/oauth/request_token"),
new Uri("https://api.twitter.com/oauth/authorize"),
new Uri("https://api.twitter.com/oauth/access_token"),
new Uri("https://mobile.twitter.com/home"),
async(IDictionary <string, string> accountProperties) =>
{
string screen_name = "";
if (accountProperties.TryGetValue("screen_name", out screen_name))
{
Xamarin.Auth.Account a = new Xamarin.Auth.Account(screen_name, accountProperties);
AuthenticatorCompletedEventArgs e = new AuthenticatorCompletedEventArgs(a);
AccountStore.Create().Save(a, AccountServiceTwitter);
await FetchTwitterData(a, loginViewModel);
}
return(null);
});
authenticator.Completed += loginViewModel.OnTwitterAuthCompleted;
authenticator.Error += loginViewModel.OnTwitterAuthError;
var presenter = new Xamarin.Auth.Presenters.OAuthLoginPresenter();
presenter.Login(authenticator);
return(false);
}
public async Task <SocialAccount> Login()
{
SocialAccount account = null;
_isComplite = false;
OAuth1Authenticator _oAuth1 = Helpers.SocialNetworkAuthenticators.TwitterAuth;
UIViewController controller = (UIViewController)_oAuth1.GetUI();
_oAuth1.Completed += async(sender, args) =>
{
account = await Helpers.SocialNetworkAuthenticators.OnCompliteTwitterAuth(args);
_isComplite = true;
controller.DismissViewController(true, null);
};
_oAuth1.Error += (sender, args) =>
{
OnError?.Invoke(args.Message);
controller.DismissViewController(true, null);
};
using (UIWindow window = new UIWindow(UIScreen.MainScreen.Bounds))
{
window.RootViewController = controller;
window.MakeKeyAndVisible();
// await user login
return(await Task.Run(() =>
{
while (!_isComplite)
{
Task.Delay(100);
}
return account;
}));
}
}
public T Factory <T>(Action <OAuthCredentials> oAuthCredentials)
where T : ResourceClient
{
var oAuthCredentialsImpl = new OAuthCredentialsImpl();
oAuthCredentials(oAuthCredentialsImpl);
var uri = new Uri($"{Behavior.HostUrl}/");
var consumerKey = "anonymous";
var consumerSecret = "anonymous";
// var client = new HttpClient(handler) {BaseAddress = uri};
var client = new RestClient(uri)
{
Authenticator = OAuth1Authenticator.ForProtectedResource(
consumerKey,
consumerSecret,
oAuthCredentialsImpl.Token,
oAuthCredentialsImpl.Secret)
};
if (Behavior.Timeout != TimeSpan.Zero)
{
client.Timeout = (int)Behavior.Timeout.TotalMilliseconds;
}
Client = client;
var type = typeof(T);
var implClass = GetType().Assembly
.GetTypes()
.FirstOrDefault(x => type.IsAssignableFrom(x) && !x.IsInterface);
return((T)Activator.CreateInstance(implClass, client));
}
private void TwitterLoginPost(string clientID, string secrete, string message, string link)
{
var auth = new OAuth1Authenticator(
consumerKey: clientID,
consumerSecret: secrete,
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("http://www.facebook.com/connect/login_success.html")
);
auth.Completed += (sender, eventArgs) =>
{
if (eventArgs.IsAuthenticated)
{
//save the account
AccountStore.Create(Forms.Context).Save(eventArgs.Account, "Twitter");
//post the message
TwitterPost(eventArgs.Account, message, clientID, secrete, link);
}
else
{
// The user cancelled during authentication. do nothing
}
};
Forms.Context.StartActivity(auth.GetUI(Forms.Context));
}
private void TwitterLoginPost(string clientID, string secrete, string message, string link)
{
var auth = new OAuth1Authenticator(
consumerKey: clientID,
consumerSecret: secrete,
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("https://www.facebook.com/connect/login_success.html")
);
auth.Completed += (sender, eventArgs) =>
{
if (eventArgs.IsAuthenticated)
{
//save the account
AccountStore.Create().Save(eventArgs.Account, "Twitter");
//post the message
TwitterPost(eventArgs.Account, message, clientID, secrete, link);
}
else
{
// The user cancelled during authentication.
c_ViewController.DismissViewController(true, null);
}
};
auth_ViewController = auth.GetUI ();
c_ViewController.PresentViewController(auth_ViewController , true, null);
}
private async Task<DataIUser> LoginToTwitter()
{
DataIUser resultUser = null;
LinqToTwitter.User twitterUser = null;
try
{
TaskCompletionSource<int> ts = new TaskCompletionSource<int>();
var auth = new OAuth1Authenticator(
consumerKey: "YVgafJLg6figpxcFTx9oBhXDw",
consumerSecret: "AdNdiuHSHIf5hN6HWnVrC9u6bnW3vVirjEhAFrfabacPIQdh98",
requestTokenUrl: new Uri("https://api.twitter.com/oauth/request_token"),
//https://api.twitter.com/oauth/authorize
authorizeUrl: new Uri("https://api.twitter.com/oauth/authorize"),
accessTokenUrl: new Uri("https://api.twitter.com/oauth/access_token"),
callbackUrl: new Uri("https://oauth.vk.com/blank.html"));
auth.AllowCancel = true;
auth.Completed += (s, ee) =>
{
if (!ee.IsAuthenticated)
{
ts.SetResult(0);
return;
}
var twitterCtx = GetTwitterContext();
var accounts =
from acct in twitterCtx.Account
where acct.Type == AccountType.VerifyCredentials
select acct;
LinqToTwitter.Account account = accounts.SingleOrDefault();
twitterUser = account.User;
#region unused requests
//var searchResponses = (from search in ctx.Search
// where search.Type == SearchType.Search
// && search.Query == searchText
// select search).SingleOrDefault();
//var tweets = from tweet in searchResponses.Statuses
// select new Message
// {
// Value = tweet.Text,
// Id = tweet.TweetIDs,
// ImageUri = tweet.User.ProfileImageUrl,
// UserName = tweet.User.ScreenNameResponse,
// Name = tweet.User.Name,
// CreatedAt = tweet.CreatedAt,
// ReTweets = tweet.RetweetCount,
// Favorite = tweet.FavoriteCount.Value
// };
//var followers = (from follower in twitterCtx.Friendship
// where follower.Type == FriendshipType.FollowersList &&
// follower.UserID == "3620214675"
// select follower).SingleOrDefault();
#endregion
string uid = twitterUser.UserIDResponse;
string firstName = twitterUser.ScreenNameResponse;
TwitterData.TwitterUser twUser = new TwitterData.TwitterUser();
twUser.ConsumerKey = twitterCtx.Authorizer.CredentialStore.ConsumerKey;
twUser.ConsumerSecret = twitterCtx.Authorizer.CredentialStore.ConsumerSecret;
twUser.OAuthToken = twitterCtx.Authorizer.CredentialStore.OAuthToken;
twUser.OAuthTokenSecret = twitterCtx.Authorizer.CredentialStore.OAuthTokenSecret;
twUser.UserID = ulong.Parse(uid);
twUser.ScreenName = firstName;
resultUser = new User()
{
FirstName = firstName,
Uid = uid,
SerializeInfo = JsonConvert.SerializeObject(twUser),
SocialNetwork = enSocialNetwork.Twitter
};
ts.SetResult(0);
};
var intent = auth.GetUI(Forms.Context);
Forms.Context.StartActivity(intent);
await ts.Task;
}
catch (Exception)
{
}
return resultUser;
}
