Changes between Version 7 and Version 8 of UseCaseImplementationsFinal

Timestamp:

03/02/26 16:21:17 (3 days ago)

Author:

231067

Comment:

--

UseCaseImplementationsFinal

@@ -33 +33 @@
 Сега, секогаш кога корисникот сака да се најави на Најди Ментор, може преку својот Google профил.
 
+{{{
+var googleId = System.Configuration.ConfigurationManager.AppSettings["GoogleClientId"];
+var googleSecret = System.Configuration.ConfigurationManager.AppSettings["GoogleClientSecret"];
+if (!string.IsNullOrWhiteSpace(googleId) && !string.IsNullOrWhiteSpace(googleSecret))
+{
+    app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions
+    {
+        ClientId = googleId,
+        ClientSecret = googleSecret,
+        CallbackPath = new PathString("/signin-google"),
+        CookieManager = cookieManager
+    });
+}
+}}}
+
+{{{
+// POST: /Account/ExternalLogin
+[HttpPost]
+[AllowAnonymous]
+[ValidateAntiForgeryToken]
+public ActionResult ExternalLogin(string provider, string returnUrl)
+{
+    // Request a redirect to the external login provider
+    var redirectUrl = Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl });
+    return new ChallengeResult(provider, redirectUrl);
+}
+
+
+// POST: /Account/ExternalLoginConfirmation
+[HttpPost]
+[AllowAnonymous]
+[ValidateAntiForgeryToken]
+public async Task<ActionResult> ExternalLoginConfirmation(WebApplication1.Models.ExternalLoginConfirmationViewModel model, string returnUrl)
+{
+    if (User.Identity.IsAuthenticated)
+    {
+        return RedirectToAction("Index", "Manage");
+    }
+
+    if (!ModelState.IsValid)
+    {
+        return View(model);
+    }
+
+    // Obtain external login info again
+    var info = await AuthenticationManager.GetExternalLoginInfoAsync();
+    if (info == null)
+    {
+        ModelState.AddModelError("", "Не можам да ги вчитам информации за надворешната најава.");
+        return View(model);
+    }
+
+    ApplicationUser user;
+    if (model.UserType == "Student")
+    {
+        user = new Student
+        {
+            UserName = model.Email,
+            Email = model.Email,
+            Name = model.Name,
+            Surname = model.Surname,
+            Biography = model.Biography,
+            Index = model.Index,
+            Major = model.Major,
+            Cycle = model.Cycle,
+            Semester = model.Semester
+        };
+    }
+    else // Mentor
+    {
+        user = new Mentor
+        {
+            UserName = model.Email,
+            Email = model.Email,
+            Name = model.Name,
+            Surname = model.Surname,
+            Biography = model.Biography,
+            Timeslots = model.Timeslots,
+            TypesOfProject = model.TypesOfProject,
+            Available = model.Available,
+            ImageURL = null
+        };
+    }
+
+    // Create user 
+    var result = await UserManager.CreateAsync(user);
+    if (!result.Succeeded)
+    {
+        AddErrors(result);
+        return View(model);
+    }
+
+    // Add the external login
+    result = await UserManager.AddLoginAsync(user.Id, info.Login);
+    if (!result.Succeeded)
+    {
+        AddErrors(result);
+        return View(model);
+    }
+
+    if (model.UserType == "Student")
+    {
+        var student = db.Users
+                        .OfType<Student>()
+                        .Include(s => s.Subjects)
+                        .Include(s => s.Topics)
+                        .SingleOrDefault(u => u.Id == user.Id);
+
+        if (student != null)
+        {
+            // clear any placeholder (should be empty for a brand new user) and add incoming items
+            student.Subjects.Clear();
+            student.Topics.Clear();
+
+            foreach (var subjName in model.Subjects ?? Enumerable.Empty<string>())
+                student.Subjects.Add(new Subject { Name = subjName, UserId = student.Id });
+
+            foreach (var topicName in model.Topics ?? Enumerable.Empty<string>())
+                student.Topics.Add(new Topic { Name = topicName, UserId = student.Id });
+
+            db.SaveChanges();
+        }
+    }
+    else // Mentor
+    {
+        var mentor = db.Users
+                       .OfType<Mentor>()
+                       .Include(m => m.Subjects)
+                       .Include(m => m.Topics)
+                       .SingleOrDefault(u => u.Id == user.Id);
+
+        if (mentor != null)
+        {
+            mentor.Subjects.Clear();
+            mentor.Topics.Clear();
+
+            foreach (var subjName in model.Subjects ?? Enumerable.Empty<string>())
+                mentor.Subjects.Add(new Subject { Name = subjName, UserId = mentor.Id });
+
+            foreach (var topicName in model.Topics ?? Enumerable.Empty<string>())
+                mentor.Topics.Add(new Topic { Name = topicName, UserId = mentor.Id });
+
+            db.SaveChanges();
+        }
+    }
+
+
+[HttpPost]
+[ValidateAntiForgeryToken]
+public ActionResult LinkLogin(string provider)
+{
+    // Request redirect to external login provider to link to current user
+    return new ChallengeResult(provider, Url.Action("LinkLoginCallback", "Account"), User.Identity.GetUserId());
+}
+
+[AllowAnonymous]
+public async Task<ActionResult> LinkLoginCallback()
+{
+    var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync(XsrfKey, User.Identity.GetUserId());
+    if (loginInfo == null)
+    {
+        return RedirectToAction("Manage", new { Message = ManageMessageId.Error });
+    }
+    var result = await UserManager.AddLoginAsync(User.Identity.GetUserId(), loginInfo.Login);
+    if (result.Succeeded)
+    {
+        return RedirectToAction("Manage", new { Message = ManageMessageId.AddLoginSuccess });
+    }
+    return RedirectToAction("Manage", new { Message = ManageMessageId.Error });
+}
+
+
+}}}
+
 = Ментор =