public ExternalAuthenticationGrant(
UserManager <TUser> userManager,
IProviderRepository providerRepository,
IFacebookAuthProvider facebookAuthProvider,
IGoogleAuthProvider googleAuthProvider,
ITwitterAuthProvider twitterAuthProvider,
ILinkedInAuthProvider linkeInAuthProvider,
INonEmailUserProcessor nonEmailUserProcessor,
IEmailUserProcessor emailUserProcessor
)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_providerRepository = providerRepository ?? throw new ArgumentNullException(nameof(providerRepository));
_facebookAuthProvider = facebookAuthProvider ?? throw new ArgumentNullException(nameof(facebookAuthProvider));
_googleAuthProvider = googleAuthProvider ?? throw new ArgumentNullException(nameof(googleAuthProvider));
_twitterAuthProvider = twitterAuthProvider ?? throw new ArgumentNullException(nameof(twitterAuthProvider));
_linkedAuthProvider = linkeInAuthProvider ?? throw new ArgumentNullException(nameof(linkeInAuthProvider));
_nonEmailUserProcessor = nonEmailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_emailUserProcessor = emailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_providers = new Dictionary <ProviderType, IExternalAuthProvider>
{
{ ProviderType.Facebook, _facebookAuthProvider },
{ ProviderType.Google, _googleAuthProvider },
{ ProviderType.Twitter, _twitterAuthProvider },
{ ProviderType.LinkedIn, _linkedAuthProvider }
};
}
public ExternalAuthenticationGrant(
UserManager <ApplicationUser> userManager,
IUnitOfWork <DatabaseContext> unitOfWork,
IExternalUserRepository externalUserRepository,
IProviderRepository providerRepository,
IFacebookAuthProvider facebookAuthProvider,
IGoogleAuthProvider googleAuthProvider,
ITwitterAuthProvider twitterAuthProvider,
ILinkedInAuthProvider linkeInAuthProvider,
INonEmailUserProcessor nonEmailUserProcessor,
IEmailUserProcessor emailUserProcessor
)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
_externalUserRepository = externalUserRepository ?? throw new ArgumentNullException(nameof(externalUserRepository));
_providerRepository = providerRepository ?? throw new ArgumentNullException(nameof(providerRepository));
_facebookAuthProvider = facebookAuthProvider ?? throw new ArgumentNullException(nameof(facebookAuthProvider));
_googleAuthProvider = googleAuthProvider ?? throw new ArgumentNullException(nameof(googleAuthProvider));
_twitterAuthProvider = twitterAuthProvider ?? throw new ArgumentNullException(nameof(twitterAuthProvider));
_linkedAuthProvider = linkeInAuthProvider ?? throw new ArgumentNullException(nameof(linkeInAuthProvider));
_nonEmailUserProcessor = nonEmailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
_emailUserProcessor = emailUserProcessor ?? throw new ArgumentNullException(nameof(nonEmailUserProcessor));
providers = new Dictionary <ProviderType, IExternalAuthProvider>();
providers.Add(ProviderType.Facebook, _facebookAuthProvider);
providers.Add(ProviderType.Google, _googleAuthProvider);
providers.Add(ProviderType.Twitter, _twitterAuthProvider);
providers.Add(ProviderType.LinkedIn, _linkedAuthProvider);
}
// GET: StudentController/Edit/5
public ActionResult GetAssignment(string id, [FromServices] IGoogleAuthProvider auth)
{
var listCourseWorkResponse = new ListCourseWorkResponse();
string pageToken = null;
do
{
var request = this.GetGoogleClassRoomService(auth).Courses.CourseWork.List(id);
request.PageSize = 100;
request.PageToken = pageToken;
var response = request.Execute();
listCourseWorkResponse = response;
} while (pageToken != null);
List <Models.CourseWork> CourseWorkList = new List <Models.CourseWork>();
foreach (CourseWork item in listCourseWorkResponse.CourseWork)
{
CourseWorkList.Add(
new Models.CourseWork()
{
CourseWorkId = item.Id,
CourseId = id,
Type = "Assigmment",
Title = item.Title,
Description = item.Description,
});
}
return(View(CourseWorkList));
}
public async Task <UserResponseModel> Google(IGoogleAuthProvider googleAuthProvider)
{
var googleResponse = await googleAuthService.GetUserData(googleAuthProvider);
var email = googleResponse.EmailAddresses.FirstOrDefault();
var userName = googleResponse.Names.FirstOrDefault();
var photo = googleResponse.Photos.FirstOrDefault();
var user = new User
{
UserName = userName.DisplayName,
Email = email.Value,
Profile = new DAL.Entities.Profile
{
Photo = photo.Url,
Status = StatusProvider.NewArtist
}
};
await userManager.CreateAsync(user);
var jwt = GenerateJwtToken(user);
return(Ok(user, jwt));
}
public ActionResult UpdateAssignment(IFormCollection collection,
[FromServices] IGoogleAuthProvider auth)
{
string courseId = collection["CourseId"];
string courseWorkId = collection["CourseWorkId"];
string answer = collection["Answer"];
Document document = new Document()
{
Title = "My Assignment " + courseWorkId
};
var docService = this.GetGoogleDocsService(auth);
var docReq = docService.Documents.Create(document);
var docRes = docReq.Execute();
string documentId = docRes.DocumentId;
string docUrl = $"https://docs.google.com/document/d/{documentId}/edit";
DocumentsResource.BatchUpdateRequest batchUpdate =
docService
.Documents
.BatchUpdate(GenerateGoogleDocText(answer), documentId);
var batchUpdateResponse = batchUpdate.Execute();
var submission = this.GetGoogleClassRoomService(auth)
.Courses
.CourseWork
.StudentSubmissions
.List(courseId, courseWorkId).Execute();
string submissionId = submission.StudentSubmissions[0].Id;
List <Attachment> attachments = new List <Attachment>()
{
new Attachment()
{
Link = new Google.Apis.Classroom.v1.Data.Link()
{
Url = docUrl
}
}
};
ModifyAttachmentsRequest body = new ModifyAttachmentsRequest()
{
AddAttachments = attachments
};
var req = this.GetGoogleClassRoomService(auth)
.Courses
.CourseWork
.StudentSubmissions
.ModifyAttachments(body, courseId, courseWorkId, submissionId).Execute();
return(Redirect(req.AlternateLink));
}
public async Task <IActionResult> Translate([FromServices] IGoogleAuthProvider auth)
{
// Check if the required scopes have been granted.
if (await auth.RequireScopesAsync(TranslateService.Scope.CloudTranslation) is IActionResult authResult)
{
// If the required scopes are not granted, then a non-null IActionResult will be returned,
// which must be returned from the action. This triggers incremental authorization.
// Once the user has granted the scope, an automatic redirect to this action will be issued.
return(authResult);
}
// The required scopes have now been granted.
GoogleCredential cred = await auth.GetCredentialAsync();
var service = new TranslateService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var translateRequest = service.Translations.Translate(new TranslateTextRequest
{
Format = "text",
Q = new List <string> {
"The cold weather will soon be over"
},
Source = "en",
Target = "fr",
});
var response = await translateRequest.ExecuteAsync();
return(View((object)response.Translations.Single().TranslatedText));
}
public ActionResult AddCourseWork(IFormCollection collection,
[FromServices] IGoogleAuthProvider auth)
{
string title = collection["Title"];
string description = collection["Description"];
string courseId = collection["CourseId"];
List <Material> materials = new List <Material>()
{
new Material()
{
Link = new Link()
{
Url = "https://www.researchgate.net/publication/303182670_Minimum_Viable_Product_or_Multiple_Facet_Product_The_Role_of_MVP_in_Software_Startups",
}
}
};
CourseWork courseWork = new CourseWork()
{
CourseId = courseId,
Title = title,
Description = description,
WorkType = "ASSIGNMENT",
MaxPoints = 100,
State = "PUBLISHED",
AssociatedWithDeveloper = true,
Materials = materials,
};
var request = this.GetGoogleClassRoomService(auth).Courses.CourseWork.Create(courseWork, courseId).Execute();
return(Redirect(request.AlternateLink));
}
public async Task <IActionResult> Translate([FromServices] IGoogleAuthProvider auth, [FromServices] ClientInfo clientInfo)
{
// Programmatic auth check.
if (await auth.RequireScopesAsync(TranslateService.Scope.CloudTranslation) is IActionResult authResult)
{
// If the required scopes are not authorized, then a non-null IActionResult will be returned,
// which must be returned from the action.
return(authResult);
}
// The required scopes have now been authorized.
var cred = await auth.GetCredentialAsync();
var service = new TranslateService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var translateRequest = service.Translations.Translate(new TranslateTextRequest
{
Format = "text",
Q = new List <string> {
"The cold weather will soon be over"
},
Source = "en",
Target = "fr",
});
var response = await translateRequest.ExecuteAsync();
return(View((object)response.Translations.Single().TranslatedText));
}
public async Task <IActionResult> StorageBucketListing([FromServices] IGoogleAuthProvider auth)
{
// Read the project ID to use to list Storage buckets.
// For demonstration purposes we are reading the project ID from the
// GOOGLE_PROJECT_ID environment variable.
// The project ID used here does not have to be the same associated to the OAuth2 Client ID
// used by your app.
string projectId = Environment.GetEnvironmentVariable(GoogleProjectIdEnvVar);
if (string.IsNullOrEmpty(projectId))
{
throw new InvalidOperationException(
$"Please set the {GoogleProjectIdEnvVar} value a Google project ID to list Storage buckets from.");
}
GoogleCredential cred = await auth.GetCredentialAsync();
var service = new StorageService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var buckets = await service.Buckets.List(projectId).ExecuteAsync();
var bucketNames = buckets.Items.Select(x => x.Name).ToList();
return(View(bucketNames));
}
public ExternalAuthenticationGrant(UserManager <User> userManager, IGoogleAuthProvider googleAuthProvider)
{
_userManager = userManager;
_googleAuthProvider = googleAuthProvider;
_providers = new Dictionary <ProviderType, IExternalAuthProvider>
{
{ ProviderType.Google, _googleAuthProvider }
};
}
public DocsService GetGoogleDocsService([FromServices] IGoogleAuthProvider auth)
{
GoogleCredential cred = auth.GetCredentialAsync().GetAwaiter().GetResult();
DocsService service = new DocsService(new BaseClientService.Initializer
{
HttpClientInitializer = cred,
ApplicationName = "WebCraft",
});
return(service);
}
public GoogleProvider(
IGoogleAuthProvider googleAuthProvider,
ILogger <GoogleProvider> logger)
{
this.googleAuthProvider = googleAuthProvider;
this.logger = logger;
this.Google = new CustomsearchService(new BaseClientService.Initializer
{
ApiKey = googleAuthProvider.GetApiKey(),
ApplicationName = GetType().ToString()
});
}
public async Task <IActionResult> ForceTokenRefresh([FromServices] IGoogleAuthProvider auth)
{
// Obtain OAuth related values before the refresh.
AuthenticateResult authResult0 = await HttpContext.AuthenticateAsync();
string accessToken0 = authResult0.Properties.GetTokenValue(OpenIdConnectParameterNames.AccessToken);
string refreshToken0 = authResult0.Properties.GetTokenValue(OpenIdConnectParameterNames.RefreshToken);
string issuedUtc0 = authResult0.Properties.IssuedUtc?.ToString() ?? "<missing>";
string expiresUtc0 = authResult0.Properties.ExpiresUtc?.ToString() ?? "<missing>";
// Force token refresh by specifying a too-long refresh window.
GoogleCredential cred = await auth.GetCredentialAsync(TimeSpan.FromHours(24));
// Obtain OAuth related values after the refresh.
AuthenticateResult authResult1 = await HttpContext.AuthenticateAsync();
string accessToken1 = authResult1.Properties.GetTokenValue(OpenIdConnectParameterNames.AccessToken);
string refreshToken1 = authResult1.Properties.GetTokenValue(OpenIdConnectParameterNames.RefreshToken);
string issuedUtc1 = authResult1.Properties.IssuedUtc?.ToString() ?? "<missing>";
string expiresUtc1 = authResult1.Properties.ExpiresUtc?.ToString() ?? "<missing>";
// As demonstration compare the old values with the new ones and check that everything is
// as it should be.
string credAccessToken = await cred.UnderlyingCredential.GetAccessTokenForRequestAsync();
bool accessTokenChanged = accessToken0 != accessToken1;
bool credHasCorrectAccessToken = credAccessToken == accessToken1;
bool pass = accessTokenChanged && credHasCorrectAccessToken;
var model = new ForceTokenRefreshModel
{
Results = new[]
{
$"Before Access Token: '{accessToken0}'",
$"Before Refresh Token: '{refreshToken0}'",
$"Before Issued UTC: '{issuedUtc0}'",
$"Before Expires UTC: '{expiresUtc0}'",
$"After Access Token: '{accessToken1}'",
$"After Refresh Token: '{refreshToken1}'",
$"After Issued UTC: '{issuedUtc1}'",
$"After Expires UTC: '{expiresUtc1}'",
$"Access token changed: {accessTokenChanged}",
$"Credential has correct access token: {credHasCorrectAccessToken}",
$"Pass: {pass}"
},
AccessToken = accessToken1
};
return(View(model));
}
public async Task <IActionResult> StorageBucketListing([FromServices] IGoogleAuthProvider auth, [FromServices] ClientInfo clientInfo)
{
var cred = await auth.GetCredentialAsync();
var service = new StorageService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var buckets = await service.Buckets.List(clientInfo.ProjectId).ExecuteAsync();
var bucketNames = buckets.Items.Select(x => x.Name).ToList();
return(View(bucketNames));
}
public async Task <IActionResult> DriveFileList([FromServices] IGoogleAuthProvider auth)
{
GoogleCredential cred = await auth.GetCredentialAsync();
var service = new DriveService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var files = await service.Files.List().ExecuteAsync();
var fileNames = files.Files.Select(x => x.Name).ToList();
return(View(fileNames));
}
public async Task OnGetAsync([FromServices] IGoogleAuthProvider auth, string BaseURL)
{
Urls url = new Urls(BaseURL);
if (string.IsNullOrEmpty(BaseURL) || !url.UrlAbsolute() || !url.UrlValid())
{
MsgText = "Service directory not found, check you have specified the correct URL"; //move all text to config
Response.Redirect(string.Format("{0}://{1}{2}", Request.Scheme, Request.Host.Host, Url.Content("~")));
return;
}
GoogleCredential credential = null;
int attempt = 0;
while (attempt < 3)
{
try
{
credential = await auth.GetCredentialAsync();
break;
}
catch (InvalidOperationException)
{
attempt++;
foreach (string key in Request.Cookies.Keys)
{
Response.Cookies.Delete(key);
}
}
}
string spreadsheetId = await GoogleSheetsExport.CreateSpreadsheetAsync(credential);
Thread t2 = new Thread(async delegate()
{
try
{
bool back = await GoogleSheetsExport.WriteToSpreadsheetAsync(spreadsheetId, credential, BaseURL, "configuration.json");
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
});
t2.Start();
Response.Redirect("https://docs.google.com/spreadsheets/d/" + spreadsheetId + "/");
}
public async Task <IEnumerable <WeatherForecast> > Get(
[FromServices] IGoogleAuthProvider googleAuthProvider)
{
AuthenticateResult auth = await HttpContext.AuthenticateAsync();
string idToken = (auth.Properties ?? throw new InvalidOperationException()).GetTokenValue(OpenIdConnectParameterNames.IdToken);
_logger.LogDebug(idToken);
if (User.Identity == null || !User.Identity.IsAuthenticated)
{
return(null);
}
return(await _weatherService.GetWeather());
}
public async Task <Person> GetUserData(IGoogleAuthProvider authProvider)
{
var credential = await authProvider.GetCredentialAsync();
var service = new PeopleServiceService(new Google.Apis.Services.BaseClientService.Initializer()
{
ApplicationName = "Disco",
HttpClientInitializer = credential
});
var response = service.People.Get("people/me").Execute();
return(response);
}
public AccountService(
IRepository <Account> accountsRepository,
IUnitOfWork unitOfWork,
ITokenService tokenService,
IVkAuthProvider vkAuthProvider,
IGoogleAuthProvider googleAuthProvider,
IFacebookAuthProvider facebookAuthProvider)
{
_accountsRepository = accountsRepository;
_unitOfWork = unitOfWork;
_vkAuthProvider = vkAuthProvider;
_googleAuthProvider = googleAuthProvider;
_facebookAuthProvider = facebookAuthProvider;
_tokenService = tokenService;
}
public AccountService(
UserManager <Player> userManager,
IJwtProvider jwtProvider,
IGoogleAuthProvider googleAuthProvider,
IFacebookAuthProvider facebookAuthProvider,
IGitHubAuthProvider gitHubAuthProvider,
IBaseUnitOfWork unitOfWork)
: base(unitOfWork)
{
_userManager = userManager;
_jwtProvider = jwtProvider;
_googleAuthProvider = googleAuthProvider;
_facebookAuthProvider = facebookAuthProvider;
_gitHubAuthProvider = gitHubAuthProvider;
}
public async Task <IActionResult> ForceTokenRefreshCheckPersisted([FromServices] IGoogleAuthProvider auth, [FromForm] string expectedAccessToken)
{
// Check that the refreshed access token is correctly persisted across requests.
var cred = await auth.GetCredentialAsync();
var credAccessToken = await cred.UnderlyingCredential.GetAccessTokenForRequestAsync();
var pass = credAccessToken == expectedAccessToken;
return(View(new[]
{
$"Expected access token: '{expectedAccessToken}'",
$"Credential access token: '{credAccessToken}'",
$"Pass: {pass}"
}));
}
public async Task <string> GetSignupUrl(IGoogleAuthProvider authProvider)
{
GoogleCredential cred = await authProvider.GetCredentialAsync();
var service = new AndroidManagementService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var createsignupUrlReq = service.SignupUrls.Create();
createsignupUrlReq.ProjectId = "nixmdm";
createsignupUrlReq.CallbackUrl = "https://localhost:5001";
SignupUrl signupUrl = await createsignupUrlReq.ExecuteAsync();
return(signupUrl.Url);
}
public async Task <IActionResult> ForceTokenRefresh([FromServices] IGoogleAuthProvider auth)
{
var authResult0 = await HttpContext.AuthenticateAsync();
var accessToken0 = authResult0.Properties.GetTokenValue(OpenIdConnectParameterNames.AccessToken);
var refreshToken0 = authResult0.Properties.GetTokenValue(OpenIdConnectParameterNames.RefreshToken);
var issuedUtc0 = authResult0.Properties.IssuedUtc?.ToString() ?? "<missing>";
var expiresUtc0 = authResult0.Properties.ExpiresUtc?.ToString() ?? "<missing>";
// Force token refresh by specifying a too-long refresh window.
var cred = await auth.GetCredentialAsync(TimeSpan.FromHours(24));
var authResult1 = await HttpContext.AuthenticateAsync();
var accessToken1 = authResult1.Properties.GetTokenValue(OpenIdConnectParameterNames.AccessToken);
var refreshToken1 = authResult1.Properties.GetTokenValue(OpenIdConnectParameterNames.RefreshToken);
var issuedUtc1 = authResult1.Properties.IssuedUtc?.ToString() ?? "<missing>";
var expiresUtc1 = authResult1.Properties.ExpiresUtc?.ToString() ?? "<missing>";
var credAccessToken = await cred.UnderlyingCredential.GetAccessTokenForRequestAsync();
var accessTokenChanged = accessToken0 != accessToken1;
var credHasCorrectAccessToken = credAccessToken == accessToken1;
var pass = accessTokenChanged && credHasCorrectAccessToken;
var model = new ForceTokenRefreshModel
{
Results = new[]
{
$"Before Access Token: '{accessToken0}'",
$"Before Refresh Token: '{refreshToken0}'",
$"Before Issued UTC: '{issuedUtc0}'",
$"Before Expires UTC: '{expiresUtc0}'",
$"After Access Token: '{accessToken1}'",
$"After Refresh Token: '{refreshToken1}'",
$"After Issued UTC: '{issuedUtc1}'",
$"After Expires UTC: '{expiresUtc1}'",
$"Access token changed: {accessTokenChanged}",
$"Credential has correct access token: {credHasCorrectAccessToken}",
$"Pass: {pass}"
},
AccessToken = accessToken1
};
return(View(model));
}
public async Task <IActionResult> Send([FromForm] SendEmailRequest request, [FromServices] IGoogleAuthProvider auth)
{
if (!ModelState.IsValid)
{
return(View("Index", new List <Destination>(_emailsService.Get())));
}
var credentials = await auth.GetCredentialAsync().ConfigureAwait(false);
var gmailService = new GmailService(new BaseClientService.Initializer
{
HttpClientInitializer = credentials,
ApplicationName = "EmailSender"
});
var destinations = _emailsService.Get();
int sections = (destinations.Count / 5) + 1;
var tasks = new List <Task>(5);
for (int i = 0; i < sections; i++)
{
var currFive = destinations.Skip(i * 5).Take(5);
tasks.Clear();
foreach (var destination in currFive)
{
string body = request.Template.Replace("{0}", destination.Name);
var message = new Message
{
Raw = EmailMessageCreator.Message(destination.Name, destination.Email, request.Subject, body)
};
var compose = new UsersResource.MessagesResource.SendRequest(gmailService, message, "me");
tasks.Add(compose.ExecuteAsync());
}
await Task.WhenAny(tasks).ConfigureAwait(false);
await Task.Delay(1000).ConfigureAwait(false);
}
_emailsService.RemoveAll();
return(Redirect("/"));
}
public ExternalGrantValidator(
IFacebookAuthProvider facebookAuthProvider,
IGoogleAuthProvider googleAuthProvider,
IAppleAuthProvider appleAuthProvider,
IUserProcessor userProcessorr)
{
_facebookAuthProvider = facebookAuthProvider;
_googleAuthProvider = googleAuthProvider;
_appleAuthProvider = appleAuthProvider;
_userProcessor = userProcessorr;
_providers = new Dictionary <ProviderType, IExternalAuthProvider>
{
{ ProviderType.Facebook, _facebookAuthProvider },
{ ProviderType.Google, _googleAuthProvider },
{ ProviderType.Apple, _appleAuthProvider },
};
}
public ActionResult EditAssignment(string courseWorkId,
string CourseId,
[FromServices] IGoogleAuthProvider auth)
{
var course = this.GetGoogleClassRoomService(auth)
.Courses.CourseWork.Get(CourseId, courseWorkId)
.Execute();
Models.CourseWork CourseWork = new Models.CourseWork()
{
CourseWorkId = courseWorkId,
CourseId = CourseId,
Title = course.Title,
Description = course.Description,
};
return(View(CourseWork));
}
public ActionResult CreateCourse(IFormCollection collection,
[FromServices] IGoogleAuthProvider auth)
{
string name = collection["Name"];
string room = collection["Room"];
string section = collection["Section"];
Link link = new Link()
{
Url = "https://webpack.js.org/loaders/css-loader/#sourcemap"
};
List <CourseMaterial> materials = new List <CourseMaterial>()
{
new CourseMaterial()
{
Link = link
}
};
List <CourseMaterialSet> materialSets = new List <CourseMaterialSet>()
{
new CourseMaterialSet()
{
Materials = materials
}
};
Course course = new Course()
{
Name = name,
Section = section,
Room = room,
CourseState = "ACTIVE",
CourseMaterialSets = materialSets,
OwnerId = "me"
};
var request = this.GetGoogleClassRoomService(auth).Courses.Create(course);
request.Execute();
return(RedirectToAction(nameof(Index)));
}
public ActionResult Index([FromServices] IGoogleAuthProvider auth)
{
var myCources = new List <Course>();
string pageToken = null;
do
{
var request = this.GetGoogleClassRoomService(auth).Courses.List();
request.PageSize = 100;
request.PageToken = pageToken;
request.StudentId = "me";
var response = request.Execute();
myCources.AddRange(response.Courses);
pageToken = response.NextPageToken;
} while (pageToken != null);
List <Models.Course> CourseList = new List <Models.Course>();
if (myCources.Count > 0)
{
foreach (Course item in myCources)
{
if (item.CourseState == "ACTIVE")
{
CourseList.Add(
new Models.Course()
{
Id = item.Id,
Name = item.Name,
Room = item.Room,
Section = item.Section,
AlternateLink = item.AlternateLink,
CourseGroupEmail = item.CourseGroupEmail,
TeacherGroupEmail = item.TeacherGroupEmail
});
}
}
}
return(View(CourseList));
}
public ActionResult GetCourseWorks(string courseId,
string className,
[FromServices] IGoogleAuthProvider auth)
{
var classRoomService = this.GetGoogleClassRoomService(auth);
var courseWorks = new List <CourseWork>();
string pageToken = null;
do
{
var request = classRoomService.Courses.CourseWork.List(courseId);
request.PageSize = 30;
request.PageToken = pageToken;
var response = request.Execute();
if (response.CourseWork != null)
{
courseWorks.AddRange(response.CourseWork);
}
} while (pageToken != null);
List <Models.CourseWork> CourseWorkList = new List <Models.CourseWork>();
foreach (CourseWork item in courseWorks)
{
CourseWorkList.Add(
new Models.CourseWork()
{
CourseWorkId = item.Id,
CourseId = courseId,
Type = "Assigmment",
Title = item.Title,
Description = item.Description,
});
}
ViewData["ClassName"] = className;
ViewData["CourseId"] = courseId;
return(View(CourseWorkList));
}
public async Task <IActionResult> AnalyticsListing([FromServices] IGoogleAuthProvider auth)
{
var cred = await auth.GetCredentialAsync();
var service = new AnalyticsService(new BaseClientService.Initializer
{
HttpClientInitializer = cred
});
var thing = await auth.GetCurrentScopesAsync();
var accounts = await service.Management.Accounts.List().ExecuteAsync();
var account = accounts.Items.First();
var accountId = "118875512";
// var properties = await service.Management.Webproperties.List(accountId).ExecuteAsync();
//var propertyId = "UA-118875512-1";
var filters = await service.Management.Filters.List(accountId).ExecuteAsync();
var matchingFilter = filters.Items.First();
matchingFilter.ExcludeDetails.ExpressionValue = "8.8.8.8";
// service.Management.Filters.Update(matchingFilter, accountId, matchingFilter.Id).Execute();
//filter.ExcludeDetails.Field = "GEO_IP_ADDRESS";
//filter.
var accountNames = accounts.Items.Select(x => x.Name).ToList();
return(View(accountNames));
}
