public async Task <IActionResult> SendEmail([FromBody] ContactRequest request)
{
var result = false;
try
{
_log.LogEntrance(nameof(SendEmail), request.ToString());
var checkGoogle = await GoogleHelper.CallGoogleSiteVerifyAsync(request.CaptchaRequest);
if (checkGoogle.IsSuccessStatusCode)
{
var responseStr = await checkGoogle.Content.ReadAsStringAsync();
_log.LogInformation($"response from google : {responseStr}");
var googleResponse = JsonConvert.DeserializeObject <GoogleVerificationResponse>(responseStr,
new JsonSerializerSettings()
{
Error = (s, e) => { e.ErrorContext.Handled = true; }
});
if (googleResponse.Success)
{
var sender = (IMailSender) new SmtpSender();
sender.Authenticate(_runtimeConfig.SmtpServer, _runtimeConfig.SmtpUserName, _runtimeConfig.SmtpPassword);
sender.SendPlain(_runtimeConfig.SmtpUserName,
_runtimeConfig.ContactUsEmails,
request.Subject,
$"From : {request.EMail}\nRequest : {request.Body}"
);
_log.LogInformation($"message sent successfull : {request.ToString()}");
result = true;
}
else
{
var errors = googleResponse.ErrorCodes == null || googleResponse.ErrorCodes.Count < 1 ?
"error from google is unclear" : string.Join(",", googleResponse.ErrorCodes);
return(NotFound(errors));
}
}
else
{
return(NotFound("Error in communication with google."));
}
return(Ok(result));
}
catch (Exception ex)
{
return(NotFound($"my exception : [{ex.Message}] [{ex.StackTrace}]"));
}
finally
{
_log.LogExit(nameof(SendEmail), result.ToString());
}
}
/// <summary>
/// 获取用户信息
/// </summary>
/// <param name="accessCode">访问代码</param>
/// <returns></returns>
public override async Task <ExternalLoginUserInfo> GetUserInfo(string accessCode)
{
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.UserAgent.ParseAdd("Microsoft ASP.NET Core OAuth middleware");
client.DefaultRequestHeaders.Accept.ParseAdd("application/json");
client.Timeout = TimeSpan.FromSeconds(30);
client.MaxResponseContentBufferSize = 1024 * 1024 * 10; // 10 MB
var request = new HttpRequestMessage(HttpMethod.Get, GoogleDefaults.UserInformationEndpoint);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessCode);
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var payload = JObject.Parse(await response.Content.ReadAsStringAsync());
return(new ExternalLoginUserInfo
{
Name = GoogleHelper.GetName(payload),
EmailAddress = GoogleHelper.GetEmail(payload),
Surname = GoogleHelper.GetFamilyName(payload),
LoginInfo = new UserLoginInfo(Name, GoogleHelper.GetId(payload))
});
}
}
/// <summary>
/// Verifies the users short code.
/// </summary>
/// <param name="manager">The manager.</param>
/// <param name="codeType">Type of the code.</param>
/// <param name="userid">The userid.</param>
/// <param name="code">The code.</param>
public async Task <bool> VerifyUserTwoFactorCodeAsync(TwoFactorComponentType component, string userid, string data)
{
var user = await FindByIdAsync(userid);
if (user == null)
{
return(false);
}
var twofactorMethod = user.TwoFactor.FirstOrDefault(x => x.Component == component);
if (twofactorMethod == null || twofactorMethod.Type == TwoFactorType.None)
{
return(true);
}
if (twofactorMethod.Type == TwoFactorType.PinCode)
{
return(twofactorMethod.Data == data);
}
if (twofactorMethod.Type == TwoFactorType.EmailCode)
{
return(await VerifyTwoFactorTokenAsync(userid, twofactorMethod.Type.ToString(), data));
}
if (twofactorMethod.Type == TwoFactorType.GoogleCode)
{
return(GoogleHelper.VerifyGoogleTwoFactorCode(twofactorMethod.Data, data));
}
return(false);
}
public async Task <OperationResult <FileDTO> > Download(FileGet file)
{
var result = new OperationResult <FileDTO>();
using (var googleService = await GoogleHelper.AuthGoogle(_configuration))
{
var reportResponse = await _clientDownload.GetResponse <OperationResult <FileReportDownloadResponse> >(new FileReportDownloadRequest
{
FileId = file.Id
});
result.Type = reportResponse.Message.Type;
result.Errors = reportResponse.Message.Errors;
var googleId = reportResponse.Message.Data.GoogleId;
var getRequest = googleService.Files.Get(googleId);
if (reportResponse.Message.IsSuccess)
{
var filestream = new MemoryStream();
await getRequest.DownloadAsync(filestream);
filestream.Seek(0, SeekOrigin.Begin);
result.Data = new FileDTO
{
FileStream = filestream,
Mime = reportResponse.Message.Data.Mime,
Name = reportResponse.Message.Data.Name
};
}
}
return(result);
}
public IActionResult GetYoutubeAccount(string code, long groupId, long userId)
{
try
{
var lstYoutubeProfiles = new List <YoutubeProfiles>();
var dbr = new DatabaseRepository(_logger, _appEnv);
lstYoutubeProfiles = GoogleHelper.GetYoutubeAccount(code, _appSettings, dbr);
var lstGrpProfiles = GroupProfilesRepository.GetAllGroupProfiles(groupId, _redisCache, dbr);
lstGrpProfiles = lstGrpProfiles.Where(t => t.profileType == SocialProfileType.YouTube).ToList();
var lstStr = lstGrpProfiles.Select(t => t.profileId).ToArray();
if (lstStr.Length > 0)
{
lstYoutubeProfiles.Where(t => lstStr.Contains(t.YtChannelId)).Select(s =>
{
s.connected = 1;
return(s);
}).ToList();
}
return(Ok(lstYoutubeProfiles));
}
catch (Exception ex)
{
_logger.LogError("GetGetYoutubeAccount" + ex.StackTrace);
_logger.LogError("GetGetYoutubeAccount" + ex.Message);
return(Ok(new List <YoutubeProfiles>()));
}
}
public ActionResult VerifyGoogleCode(string key, string code)
{
if (GoogleHelper.VerifyGoogleTwoFactorCode(key, code))
{
return(JsonSuccess());
}
return(JsonError());
}
public void GetDistances()
{
if (tblResults != null && tblResults.Rows.Count > 0)
{
//Add a new column to the table specific to Google so we don't step on any of the original data
DataColumn googleColumn = new DataColumn("GoogleDistance");
tblResults.Columns.Add(googleColumn);
//Setup the string we'll use as the origin Lat/Lng for Google
String originString = String.Format("{0},{1}", lat, lng);
//Setup a list of Lat/Lng destinations to loop through based off of the data from the databse
List <String> destinations = new List <String>();
for (Int32 i = 0; i < tblResults.Rows.Count; i++)
{
destinations.Add(String.Format("{0},{1}",
tblResults.Rows[i]["Latitude"].ToString(),
tblResults.Rows[i]["Longitude"].ToString()));
}
//Call the GoogleHelper with what we've put together and store the results in a String array
String[] distances = GoogleHelper.GetDistances(originString, destinations.ToArray());
//Loop through the rows in the data table again and update with what we received from Google
for (Int32 i = 0; i < tblResults.Rows.Count; i++)
{
if ((i + 1) <= distances.Length)
{
//If we received a distance for this destination...
if (distances[i] != "")
{
//Update our Distance with Google's for Display
tblResults.Rows[i]["Distance"] = distances[i].ToString();
//Update our Numeric Distance with Google's for sorting
tblResults.Rows[i]["NumericDistance"] = Convert.ToDouble(distances[i].Replace(" mi", String.Empty).Trim());
}
else
{
//Update our Distance with our calculated Numeric Distance as a fallback
tblResults.Rows[i]["Distance"] = String.Format("{0:##0.0} mi",
tblResults.Rows[i]["NumericDistance"]);
}
}
else
{
//Update our Distance with our calculated Numeric Distance as a fallback
tblResults.Rows[i]["Distance"] = String.Format("{0:##0.0} mi",
tblResults.Rows[i]["NumericDistance"]);
}
}
}
}
private static void ProcessGoogle(AppSettings config, IList <Transaction> transactions)
{
var google = new GoogleHelper(config);
var values = google.BuildList(transactions);
var response = google.Append(values).Result;
WriteLine("Finished appending values!");
WriteLine($"Updated range: {response.Updates.UpdatedRange}");
WriteLine($"Updated rows: {response.Updates.UpdatedRows}");
WriteLine($"Updated columns: {response.Updates.UpdatedColumns}");
WriteLine($"Updated cells: {response.Updates.UpdatedCells}");
}
public async Task <IActionResult> HandleRedirect(string returnUrl)
{
if (returnUrl.IsNullEmptyOrWhiteSpace())
{
returnUrl = ApplicationEngine.RouteUrl(RouteNames.Home);
}
var request = await GoogleHelper.CreateConnectedAccountRequestAsync();
if (_connectionAccountant.Connect(request))
{
return(Redirect(returnUrl));
}
return(RedirectToRoute(RouteNames.Login));
}
internal static Task OnCreatingTicket(OAuthCreatingTicketContext context)
{
if (context.Ticket.Principal != null)
{
Helpers.ThrowIfConditionFailed(() => context.AccessToken == "ValidAccessToken", "Access token is not valid");
Helpers.ThrowIfConditionFailed(() => context.RefreshToken == "ValidRefreshToken", "Refresh token is not valid");
Helpers.ThrowIfConditionFailed(() => GoogleHelper.GetEmail(context.User) == "*****@*****.**", "Email is not valid");
Helpers.ThrowIfConditionFailed(() => context.ExpiresIn.Value == TimeSpan.FromSeconds(1200), "ExpiresIn is not valid");
Helpers.ThrowIfConditionFailed(() => context.User != null, "User object is not valid");
context.Ticket.Principal.Identities.First().AddClaim(new Claim("ManageStore", "false"));
}
return(Task.FromResult(0));
}
public void Test1()
{
var captchaEncrypted = @"03AOLTBLQqSv7BqJvZBSSd6ieO1FGaq7pnyn7JY_yXDoKpKwcJXDq8buuP6jBL5B5UjhVP7votjIVX2_Ok08PgrxMK0MDmlLRwScCdH_DxP7Bx6_fIpyJ-fAU2jD96-wnGMVpHNwu3tGM1UajJcSQw580NFV9yndSLCp3G4clrHmlaYaOUqgwOh2CCeKiGy8-Pw_NAYZI58Ii6QI3OqF-vwxV1fdsUrh88oXcVitc2Ad8N0fLqY68HvBmVYjzkW1Zvx77nm4Q6cEC8Twf4TYVcB_IBnLfbiz59klCfBB0b8aChW0zXn0uAzVn5XZJpVxM2BgUrtyaAaMJbh9Vvxi-gCJN76TtLFM8aTI7lGhtGulw99sh30N4lDGY064S7jJ9iOx8Cm1QoO6IS";
var googleResponseTask = GoogleHelper.CallGoogleSiteVerifyAsync(captchaEncrypted);
while (!googleResponseTask.IsCompleted)
{
Thread.Sleep(200);
}
if (googleResponseTask.Result.IsSuccessStatusCode)
{
var readAsStrTask = googleResponseTask.Result.Content.ReadAsStringAsync();
while (!readAsStrTask.IsCompleted)
{
Thread.Sleep(200);
}
output.WriteLine($"raw result = {readAsStrTask.Result}");
var googleResponse =
JsonConvert.DeserializeObject <GoogleVerificationResponse>(readAsStrTask.Result,
new JsonSerializerSettings()
{
Error = (s, e) => { e.ErrorContext.Handled = true; },
//Error = HandleErrors,
});
output.WriteLine($"google success = {googleResponse.Success}");
output.WriteLine($"google host = {googleResponse.hostname}");
var errors = googleResponse.ErrorCodes == null ? "" : string.Join(',', googleResponse.ErrorCodes);
output.WriteLine($"google errors = {errors} ");
if (googleResponse.Success)
{
output.WriteLine($"Successful recaptcha!");
}
}
Assert.Equal(1, 1);
}
public async Task <ExternalLoginInfo> CreateExternalLogin(string provider, string token)
{
switch (provider)
{
case ExternalProvider.Facebook:
{
var payload = await FacebookHelper.GetFacebookUser(token);
var cp = FacebookHelper.GetClaims(payload);
if (cp == null)
{
return(null);
}
return(new ExternalLoginInfo(cp, ExternalProvider.Facebook, FacebookHelper.GetId(payload), ExternalProvider.Facebook));
}
case ExternalProvider.Google:
{
var payload = await GoogleHelper.GetGoogleUser(token);
var cp = GoogleHelper.GetClaims(payload);
if (cp == null)
{
return(null);
}
return(new ExternalLoginInfo(cp, ExternalProvider.Google, GoogleHelper.GetId(payload), ExternalProvider.Google));
}
case ExternalProvider.Wechat:
{
string[] variables = token.Split(":");
var payload = await WechatHelper.GetWechatUser(variables[0], variables[1]);
var cp = WechatHelper.GetClaims(payload);
if (cp == null)
{
return(null);
}
return(new ExternalLoginInfo(cp, ExternalProvider.Wechat, WechatHelper.GetId(payload), ExternalProvider.Wechat));
}
default:
return(null);
}
}
public async Task <OperationResult <FileDTO> > Upload(FilePost file)
{
var googleService = await GoogleHelper.AuthGoogle(_configuration);
using (var stream = file.File.OpenReadStream())
{
var uploadResponse = await GoogleHelper.Upload(_configuration, googleService, stream, file.File);
var result = new OperationResult <FileDTO>
{
Type = uploadResponse.Type,
Errors = uploadResponse.Errors
};
if (uploadResponse.IsSuccess)
{
var reportResponse = await _clientUpload.GetResponse <OperationResult <FileReportUploadResponse> >(new FileReportUploadRequest
{
Description = file.Description,
Name = file.File.FileName,
GoogleId = uploadResponse.Data.Id,
Mime = file.File.ContentType,
ReportId = file.ReportId
});
result.Type = reportResponse.Message.Type;
result.Errors.AddRange(reportResponse.Message.Errors);
if (reportResponse.Message.IsSuccess)
{
result.Data = new FileDTO
{
FileId = reportResponse.Message.Data.FileId
};
}
}
return(result);
}
}
public static ObservableCollection <StockData> GetStockDataFromGoogle(string ticker, DateTime startDate, DateTime endDate)
{
ObservableCollection <StockData> res = new ObservableCollection <StockData>();
ObservableCollection <GoogleStockPrice> dt = GoogleHelper.GetGoogleStockData(ticker, startDate, endDate, GoogleDataTypeEnum.EOD);
if (dt.Count > 0)
{
foreach (var p in dt)
{
res.Add(new StockData
{
Ticker = ticker,
Date = p.Date.Date,
Open = p.PriceOpen.To <double>(),
High = p.PriceHigh.To <double>(),
Low = p.PriceLow.To <double>(),
Close = p.PriceClose.To <double>(),
Volume = p.Volume.To <double>()
});
}
}
return(res);
}
public ActionResult Create(TwoFactorComponentType componentType)
{
var user = UserManager.FindById(User.Id());
if (user == null)
{
return(Unauthorized());
}
// If twofactor exists something is dodgy, return unauthorised
var twofactor = user.TwoFactor.FirstOrDefault(x => x.Component == componentType && x.Type != TwoFactorType.None);
if (twofactor != null)
{
return(RedirectToRoute("Security"));
}
return(View(new CreateTwoFactorModel
{
ComponentType = componentType,
GoogleData = GoogleHelper.GetGoogleTwoFactorData(user.UserName)
}));
}
public CustomEventDataSource(CalendarService calendarService, string calendarId, string timeZoneId)
{
this.googleHelper = new GoogleHelper(calendarService, calendarId, timeZoneId);
}
// POST: api/Woow
public object Post([FromBody] Zero.ApiTerminal.Clients.Request.WoowRequest request)
{
object result = null;
Logger.Info("PARSE REQUEST:" + request.SerializeXml());
BaseHelper helper = null;
switch (request.ChannelSymbol)
{
case 1:
helper = new MsonlineHelper();
break;
case 2:
helper = new GoogleHelper();
break;
}
if (helper != null)
{
helper.Channel = request.Channel;
helper.Avatar = request.Avatar;
}
else
{
return("");
}
Logger.Debug(helper.GetType());
switch ((request.Method + "").ToUpper())
{
case "SIGNIN":
result = helper.Signin();
break;
case "EXCHANGETOKEN":
result = helper.ExchangeToken(request.Data);
break;
case "REFRSHTOKEN":
result = helper.RefreshToken(request.Data);
break;
case "READAVATAR":
result = helper.ReadAvatar();
break;
case "READMESSAGES":
Logger.Debug("READMESSAGES");
result = helper.ReadMessages(request.Data.ToInt());
break;
case "READCONTACTS":
Logger.Debug("READCONTACTS");
result = helper.ReadContacts(request.Data.ToInt());
break;
case "READEVENTS":
Logger.Debug("READEVENTS");
result = helper.ReadEvents(request.Data.ToInt());
break;
case "CREATEEVENT":
result = helper.CreateEvent(request.Data.JsonToObj <Zero.ApiTerminal.Entities.Event>());
break;
case "CANCELEVENT":
result = helper.CancelEvent(request.Data.JsonToObj <Zero.ApiTerminal.Entities.Event>());
break;
case "UPDATEEVENT":
result = helper.UpdateEvent(request.Data.JsonToObj <Zero.ApiTerminal.Entities.Event>());
break;
}
Logger.Info("CALLBACK:" + result);
return(result);
}
public GoogleFileProvider()
{
var googleHelper = new GoogleHelper(Configuration.Instance.GoogleConfig);
_driveService = new DriveService(googleHelper.GetInitializer(scopes: DriveService.Scope.Drive));
}
public GoogleFileProvider(IConfiguration config)
{
var googleHelper = new GoogleHelper(config);
_driveService = new DriveService(googleHelper.GetInitializer());
}
protected override async Task <AuthenticationTicket> CreateTicketAsync(
ClaimsIdentity identity,
AuthenticationProperties properties,
OAuthTokenResponse tokens)
{
log.LogDebug("CreateTicketAsync called tokens.AccessToken was " + tokens.AccessToken);
// Get the Google user
var request = new HttpRequestMessage(HttpMethod.Get, Options.UserInformationEndpoint);
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", tokens.AccessToken);
var response = await Backchannel.SendAsync(request, Context.RequestAborted);
//string r = await response.Content.ReadAsStringAsync();
//log.LogInformation(r);
response.EnsureSuccessStatusCode();
var payload = JObject.Parse(await response.Content.ReadAsStringAsync());
var context = new OAuthCreatingTicketContext(Context, Options, Backchannel, tokens, payload)
{
Properties = properties,
Principal = new ClaimsPrincipal(identity)
};
var identifier = GoogleHelper.GetId(payload);
if (!string.IsNullOrEmpty(identifier))
{
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, identifier, ClaimValueTypes.String, Options.ClaimsIssuer));
}
var givenName = GoogleHelper.GetGivenName(payload);
if (!string.IsNullOrEmpty(givenName))
{
identity.AddClaim(new Claim(ClaimTypes.GivenName, givenName, ClaimValueTypes.String, Options.ClaimsIssuer));
}
var familyName = GoogleHelper.GetFamilyName(payload);
if (!string.IsNullOrEmpty(familyName))
{
identity.AddClaim(new Claim(ClaimTypes.Surname, familyName, ClaimValueTypes.String, Options.ClaimsIssuer));
}
var name = GoogleHelper.GetName(payload);
if (!string.IsNullOrEmpty(name))
{
identity.AddClaim(new Claim(ClaimTypes.Name, name, ClaimValueTypes.String, Options.ClaimsIssuer));
}
var email = GoogleHelper.GetEmail(payload);
if (!string.IsNullOrEmpty(email))
{
identity.AddClaim(new Claim(ClaimTypes.Email, email, ClaimValueTypes.String, Options.ClaimsIssuer));
}
var profile = GoogleHelper.GetProfile(payload);
if (!string.IsNullOrEmpty(profile))
{
identity.AddClaim(new Claim("urn:google:profile", profile, ClaimValueTypes.String, Options.ClaimsIssuer));
}
await Options.Events.CreatingTicket(context);
//ISiteSettings site = siteResolver.Resolve();
var site = await GetSite();
if (site != null)
{
Claim siteGuidClaim = new Claim("SiteGuid", site.SiteGuid.ToString());
if (!identity.HasClaim(siteGuidClaim.Type, siteGuidClaim.Value))
{
identity.AddClaim(siteGuidClaim);
}
}
//return new AuthenticationTicket(notification.Principal, notification.Properties, notification.Options.AuthenticationScheme);
return(new AuthenticationTicket(context.Principal, context.Properties, AuthenticationScheme.External));
}
public CustomEventDataSource()
{
this.googleHelper = new GoogleHelper(null, String.Empty, string.Empty);
}
