Microsoft Graph API

// Install: dotnet add package Microsoft.Graph
//         dotnet add package Microsoft.Graph.Auth

using Microsoft.Graph;
using Microsoft.Graph.Auth;
using Microsoft.Identity.Client;

public class GraphService
{
    private readonly GraphServiceClient _graphServiceClient;

    public GraphService(IConfiguration configuration)
    {
        // Konfiguration från appsettings.json
        var clientId = configuration["AzureAd:ClientId"];
        var clientSecret = configuration["AzureAd:ClientSecret"];
        var tenantId = configuration["AzureAd:TenantId"];

        // Skapa MSAL-klient för autentisering
        var confidentialClientApplication = ConfidentialClientApplicationBuilder
            .Create(clientId)
            .WithClientSecret(clientSecret)
            .WithAuthority(new Uri($"https://login.microsoftonline.com/{tenantId}"))
            .Build();

        // Skapa Graph-klient
        var authProvider = new ClientCredentialProvider(confidentialClientApplication);
        _graphServiceClient = new GraphServiceClient(authProvider);
    }

    // Hämta alla användare
    public async Task<List<User>> GetUsersAsync()
    {
        var users = await _graphServiceClient.Users
            .Request()
            .Select("id,displayName,mail,userPrincipalName")
            .GetAsync();

        return users.ToList();
    }

    // Hämta specifik användare
    public async Task<User> GetUserAsync(string userId)
    {
        return await _graphServiceClient.Users[userId]
            .Request()
            .GetAsync();
    }

    // Hämta användarens emails
    public async Task<List<Message>> GetUserEmailsAsync(string userId)
    {
        var messages = await _graphServiceClient.Users[userId].Messages
            .Request()
            .Select("subject,from,receivedDateTime,bodyPreview")
            .Top(10)
            .OrderBy("receivedDateTime desc")
            .GetAsync();

        return messages.ToList();
    }
}

// Program.cs för web-app med Microsoft Graph
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.Authorization;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.UI;

var builder = WebApplication.CreateBuilder(args);

// Lägg till Microsoft Identity Web
builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(builder.Configuration.GetSection("AzureAd"))
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddMicrosoftGraph(builder.Configuration.GetSection("MicrosoftGraph"))
    .AddInMemoryTokenCaches();

// Kräv autentisering för alla controllers
builder.Services.AddControllersWithViews(options =>
{
    var policy = new AuthorizationPolicyBuilder()
        .RequireAuthenticatedUser()
        .Build();
    options.Filters.Add(new AuthorizeFilter(policy));
});

builder.Services.AddRazorPages().AddMicrosoftIdentityUI();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.MapRazorPages();

app.Run();

// Controller som använder Graph
[Authorize]
public class HomeController : Controller
{
    private readonly GraphServiceClient _graphServiceClient;

    public HomeController(GraphServiceClient graphServiceClient)
    {
        _graphServiceClient = graphServiceClient;
    }

    public async Task<IActionResult> Index()
    {
        // Hämta inloggad användares profil
        var user = await _graphServiceClient.Me
            .Request()
            .GetAsync();

        ViewBag.UserName = user.DisplayName;
        ViewBag.UserEmail = user.Mail;

        return View();
    }

    public async Task<IActionResult> Emails()
    {
        // Hämta användarens emails
        var messages = await _graphServiceClient.Me.Messages
            .Request()
            .Select("subject,from,receivedDateTime,bodyPreview")
            .Top(20)
            .OrderBy("receivedDateTime desc")
            .GetAsync();

        return View(messages);
    }

    public async Task<IActionResult> Calendar()
    {
        // Hämta kommande kalenderhändelser
        var events = await _graphServiceClient.Me.Calendar.Events
            .Request()
            .Filter($"start/dateTime ge '{DateTime.Now:yyyy-MM-ddTHH:mm:ss}'")
            .OrderBy("start/dateTime")
            .Top(10)
            .GetAsync();

        return View(events);
    }
}

public async Task SendEmailAsync(string recipientEmail, string subject, string body)
{
    var message = new Message
    {
        Subject = subject,
        Body = new ItemBody
        {
            ContentType = BodyType.Html,
            Content = body
        },
        ToRecipients = new List<Recipient>
        {
            new Recipient
            {
                EmailAddress = new EmailAddress
                {
                    Address = recipientEmail
                }
            }
        }
    };

    await _graphServiceClient.Me.SendMail(message)
        .Request()
        .PostAsync();
}

public async Task<Event> CreateCalendarEventAsync(string subject, DateTime startTime, DateTime endTime)
{
    var newEvent = new Event
    {
        Subject = subject,
        Start = new DateTimeTimeZone
        {
            DateTime = startTime.ToString("yyyy-MM-ddTHH:mm:ss"),
            TimeZone = "Europe/Stockholm"
        },
        End = new DateTimeTimeZone
        {
            DateTime = endTime.ToString("yyyy-MM-ddTHH:mm:ss"),
            TimeZone = "Europe/Stockholm"
        }
    };

    return await _graphServiceClient.Me.Calendar.Events
        .Request()
        .AddAsync(newEvent);
}

public async Task<DriveItem> UploadFileAsync(string fileName, Stream fileStream)
{
    return await _graphServiceClient.Me.Drive.Root
        .ItemWithPath(fileName)
        .Content
        .Request()
        .PutAsync<DriveItem>(fileStream);
}

// Retry-logic för Graph API
public async Task<T> ExecuteWithRetryAsync<T>(Func<Task<T>> graphCall)
{
    int maxRetries = 3;
    int delay = 1000; // ms

    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await graphCall();
        }
        catch (ServiceException ex) when (ex.Error.Code == "TooManyRequests")
        {
            if (i == maxRetries - 1) throw;

            // Vänta längre för varje retry
            await Task.Delay(delay * (int)Math.Pow(2, i));
        }
    }

    throw new Exception("Max retries exceeded");
}