Integration Guide for Effortless Microsoft Graph API Access

public interface IMSGraphEventAccess
{
    /// <summary>
    /// CreateEventAsync -> Create a calendar event based on the data
    /// </summary>
    /// <param name="OrganizerEmail">Who creates an event</param>
    /// <param name="dataForPost">Event Data</param>
    /// <returns></returns>
    Task<Event> CreateEventAsync(string OrganizerEmail, Event dataForPost);

    /// <summary>
    /// CancelEventAsync -> Cancel an event by ID
    /// </summary>
    /// <param name="OrganizerEmail"></param>
    /// <param name="EventId">Event ID</param>
    /// <returns></returns>
    Task CancelEventAsync(string OrganizerEmail, string EventId);

    /// <summary>
    /// GetEventAsync -> Get an event by ID
    /// </summary>
    /// <param name="OrganizerEmail"></param>
    /// <param name="EventId"></param>
    /// <returns></returns>
    Task<Event> GetEventAsync(string OrganizerEmail, string EventId);

    /// <summary>
    /// UpdateEventAsync ->  Update an event by event data
    /// </summary>
    /// <param name="OrganizerEmail">Who created an event</param>
    /// <param name="dataForPost">Data</param>
    /// <returns></returns>
    Task<Event> UpdateEventAsync(string OrganizerEmail, Event dataForPost);
}

public interface IMSGraphUserAccess
{
    /// <summary>
    /// Gettting User Details by mail 
    /// </summary>
    /// <param name="UserEmail"></param>
    /// <returns></returns>
    Task<User> GetUserDetailsAsync(string UserEmail);
}

The class implementation is as follows.

public class GraphUserAPIAccessor : IMSGraphUserAccess
{
    private readonly GraphServiceClient _graphServiceClient;

    public GraphUserAPIAccessor(IMSGraphServiceClient graphServiceClient)
    {
        _graphServiceClient = graphServiceClient.GraphServiceClient;
    }

    /// <summary>
    /// Get User Details by mail 
    /// </summary>
    /// <param name="UserEmail"></param>
    /// <returns></returns>
    public async Task<User> GetUserDetailsAsync(string UserEmail) =>
        await _graphServiceClient.Users[UserEmail].GetAsync() ?? new User();
}

public class GraphEventAPIAccessor : IMSGraphEventAccess
{
    private readonly GraphServiceClient _graphServiceClient;

    public GraphEventAPIAccessor(IMSGraphServiceClient graphServiceClient)
    {
        _graphServiceClient = graphServiceClient.GraphServiceClient;
    }

    /// <summary>
    /// CreateEventAsync -> Create a calendar event based on the data
    /// </summary>
    /// <param name="OrganizerEmail">Who creates an event</param>
    /// <param name="dataForPost">Event Data</param>
    /// <returns></returns>
    public async Task<Event> CreateEventAsync(string OrganizerEmail, Event dataForPost) =>
        await _graphServiceClient.Users[OrganizerEmail].Calendar.Events.PostAsync(dataForPost) ?? new Event();

    /// <summary>
    /// CancelEventAsync -> Cancel an event by ID
    /// </summary>
    /// <param name="OrganizerEmail"></param>
    /// <param name="EventId">Event ID</param>
    /// <returns></returns>
    public async Task CancelEventAsync(string OrganizerEmail, string EventId)
    {
        try
        {
            var eventGet = await _graphServiceClient.Users[OrganizerEmail].Calendar.Events[EventId].GetAsync();
            if (eventGet != null)
            {
                await _graphServiceClient.Users[OrganizerEmail].Calendar.Events[EventId].DeleteAsync();
            }
            else
            {
                throw new Exception("No Event Found");
            }
        }
        catch
        {
            throw;
        }
    }

    /// <summary>
    /// UpdateEventAsync -> Update an event by event data
    /// </summary>
    /// <param name="OrganizerEmail">Who created an event</param>
    /// <param name="dataForPost">Data</param>
    /// <returns></returns>
    public async Task<Event> UpdateEventAsync(string OrganizerEmail, Event dataForPost)
    {
        try
        {
            var eventGet = await _graphServiceClient.Users[OrganizerEmail].Calendar.Events[dataForPost.Id].GetAsync();
            if (eventGet != null)
            {
                return await _graphServiceClient.Users[OrganizerEmail].Calendar.Events[dataForPost.Id].PatchAsync(dataForPost) ?? new Event();
            }
            else
            {
                throw new Exception("No Event Found");
            }
        }
        catch
        {
            throw;
        }
    }

    public async Task<Event> GetEventAsync(string OrganizerEmail, string EventId) =>
        await _graphServiceClient.Users[OrganizerEmail].Calendar.Events[EventId].GetAsync() ?? new Event();
}

Inject the details at the startup of the Service.

// TODO Read from Configurations
builder.Services.AddSingleton<IMSGraphServiceClient>(x => new MSGraphServiceClient(
    TenantId: "",
    ClientId: "",
    ClientSecret: ""
));

builder.Services.AddScoped<IMSGraphUserAccess, GraphUserAPIAccessor>();
builder.Services.AddScoped<IMSGraphEventAccess, GraphEventAPIAccessor>();

Implementation and Access of the resources (User Details and Event - Calendar Meetings).

 public class HomeController(ILogger<HomeController> logger, IMSGraphEventAccess mSGraphEventAccess, IMSGraphUserAccess mSGraphUser) : Controller
 {
     private readonly ILogger<HomeController> _logger = logger;
     private readonly IMSGraphEventAccess _mSGraphEventAccess = mSGraphEventAccess;
     private readonly IMSGraphUserAccess _mSGraphUser = mSGraphUser;

     public async void MSGraphAPIAccessingEvent()
     {     
         Event testing = new()
         {
             Attendees =[
                 new() { EmailAddress = new EmailAddress() { Address = "[email protected]", Name = "User 1" } },
                 new() { EmailAddress = new EmailAddress() { Address = "[email protected]", Name = "User 2" } }
             ],
             Body = new ItemBody() { Content = "Testing Meeting Updated Content <b> Welcome </b>" },
             CreatedDateTime = DateTime.Now,
             End = new DateTimeTimeZone() { DateTime = DateTime.Now.AddDays(1).AddHours(4).ToString("yyyy-MM-dd hh:mm:ss"), TimeZone = TimeZoneInfo.Local.StandardName },
             Start = new DateTimeTimeZone() { DateTime = DateTime.Now.AddDays(1).AddHours(2).ToString("yyyy-MM-dd hh:mm:ss"), TimeZone = TimeZoneInfo.Local.StandardName },
             Location = new Location() { DisplayName = "Office Conf Room #344 A" },
             Subject = "Testing Meeting Updated Content",
             Categories = ["Interview"]
         };
         try
         {
             string orgnUser = "[email protected]";

             var details =await _mSGraphUser.GetUserDetailsAsync(orgnUser);

             var createdEvent = await _mSGraphEventAccess.CreateEventAsync(orgnUser, testing);

             var eventGet = await _mSGraphEventAccess.GetEventAsync(orgnUser, createdEvent.Id ?? "");
             if (eventGet != null)
             {
                 eventGet.Location = new Location() { DisplayName = "Office Conf Room #342 B" };
                 var updatedEvent = await _mSGraphEventAccess.UpdateEventAsync(orgnUser, eventGet);

                 await _mSGraphEventAccess.CancelEventAsync(orgnUser, updatedEvent.Id ?? "");
             }
         }
         catch (Exception exp)
         {
             _logger.LogCritical(exp.Message);
         }
     }        
 }

That's all. We will see in detail about the Single Sign On of Microsoft in the Next Article.