Top 3 Microsoft Office 365 Backup Solution – Free and Paid

The blog deals with all the possible Microsoft Office 365 backup solutions. The backup solutions can save the Office 365 mailbox data in the Outlook PST file format. This is the preventive measures to safeguard the data for the future purpose. In case, any mishappening occurs, the data is still accessible. It is recommended to the users to obtain the backup of the Office 365 data at a regular period of time.

Additionally, Office 365 stores its data in the cloud storage. This makes it very easy for the user to avail the data from anywhere at anytime.  But, no software is devoid of the drawbacks completely. The problem with this technology is that it does not provide any timely backup of the mailboxes in the local system. The data can be accessed only in the cloud. This can result in a crucial problem when the data gets damaged or hacked. Thus, the need to keep the backup of data arises.

Methodology to Backup Office 365 Data

There are different types of approaches to export mailbox from Office 365 to PST file. These are:

Solution 1: Office 365 Export Tool – Paid (100% Accuracy)

This is the most effective Microsoft Office 365 mailbox backup solution. This can be done by admin as well as individual users. This is a standalone program which does not require the presence of any other supporting application. All a user needs to do is download and install the Office 365 export utility from its official website (http://www.office365export.com/) . Discussed below are the steps that a user needs to follow to archive Office 365 mailboxes as PST for both, admin and non-admin accounts.

For Admin Account

  1. Double-click on the Office 365 export program icon and select the option of login.a
  2. Select the checkbox named as Is Admin.b
  3. Type the credentials of the required Admin account.c
  4. All the user IDs present under that admin account will be displayed on the screen. dSelect the IDs which you wish to backup. Click Next to continue the export process.
  5. Select any of the file formats from the heading Select Email Format. In this example, the alternative of PST is chosen from the list to download Office 365 mailboxes as PST.e
  6. If you have selected the option of PST, then there is a feature to split the resultant PST file. This will prevent the file size corruption.f
  7. From the different categories available, a user has to select the different components like emails, contacts, calendars or tasks.g
  8. The filters like date filter can be applied while backing up the items.h
  9. Click on the option of browse to define the location where the obtained PST files are to be stored after the entire export process is finished.i
  10. Choose the selected folders on the local system and select the OK option to carry on the procedure to save Office 365 mailboxes as PST.j
  11. Finally, click on the Export button to start the backup procedure.k
  12. The status of the live export process will be shown up on the screen. Also, it can be stopped in between with the help of Pause option available.l
  13. Once the export procedure is finished, the status will change from in progress to completed.m
  14. The status report of the process can be saved by clicking on the option of Save Report and define its destination location.n
  15. At the last, the data from Office 365 admin account will be saved in the local system.o

For Individual Account

To backup Office 365 mailboxes as PST for any normal user account, a user has to go through the following steps:

  • Launch the Office 365 export tool and select the option of login.
  • Enter the credentials of individual user account and click on the option of sign in.
  • The folders and sub-folders will be displayed the screen. Press on Next to export Office 365 mailboxes to PST.
  • Now, the further process will be same as the admin account from (5) to (10).

Solution 2: With the Help of eDiscovery Tool – Free

ediscovery Office 365 is the administrative feature which is quite helpful in backing up the Office 365 data. It is capable of performing searches related to the discovery of different mailboxes. This service of Office 365 is quite helpful in saving Office 365 mailboxes to PST. A user needs to go through the following steps to backup the Office 365 data to PST:

  1. Enable the permissions regarding security and compliance for eDiscovery1
  2. Create a case for the eDiscovery feature under search and investigation section2
  3. Add new users in the case of recently created eDiscovery tool3
  4. Add the already existing on legal hold to retain case relevant content
  5. Now, at this time it is required to generate and run single or multiple content searches with the case.

Solution 3: With the Help of PowerShell Command – Free

This includes a set of PowerShell commands to backup Office 365 mailboxes as PST. A user has to follow the below-mentioned steps to carry out the export process:

  1. Connect the local machine with the Microsoft Exchange Server
  2. Grant the necessary permissions to access export right
  3. Configure the Exchange online account in MS Outlook
  4. Authenticate the configuration settings of Microsoft Outlook
  5. From the currently opened email client, export the PST file
  6. Make sure that the export process is finished
  7. Remove the permissions granted in Step 2
  8. Disable all the connections made in Step 1

For more info: http://technewskb.com/backup-office-365-mailbox-pst/

Time to Wrap Up

Office 365 is an email client which offers some amazing facilities like storing the data in the cloud. No doubt, there are many advantages of the cloud storage. But, it can leads to a serious problem when the data is corrupted and becomes inaccessible. Hence, it is advised to keep the backup of Office 365 data. There are different manual and automated methods available for it. But, the most effective Office 365 backup solutions is Office 365 export tool.

You can connect me @Twitter.

Advertisements

ASP.Net Web API with Fiddler and Postman

Description: In this article, we will learn about the concept of ASP.NET Web API using Visual Studio 2015. Also, we will learn to test Web API using Fiddler and Postman Clients.

Agenda:

  • Creating the very basic WebApi project in Visual Studio
  • Create methods to perform CRUD (Create, Read, Update and Delete) operations with WebApi Controller using ADO.NET Entity Framework 6.1.3
  • Learn the way to make your WebApi return data in specific formats like JSON, XML etc.
  • Downloading and installing Fiddler tool and testing the WebApi with it
  • Downloading and installing Postman tool and testing the WebApi with it

ASP.NET Web API is a framework that allow us to build HTTP services over the top of .NET Framework. It is so flexible that it can reach a broad range of clients, including browsers and portable devices. It’s main feature, which makes it unique, is that it is RESTful (Representational State Transfer) i.e. all that data is passed over HTTP and not on SOAP like that of WCF Services.

Unlike SOAP, a WebApi works on pre-defined standards i.e. it has pre-defined verbs, known as HTTP verbs, to work. These verbs are mentioned below:

  1. GET – It is used to fetch the data
  2. PUT – It is used to update the data
  3. POST – It is used to create the data
  4. DELETE – It is used to delete the data

Note: ASP.NET WebApi works on the MVC (Model-View-Controller) architectural pattern, so MVC is a pre-requisite.

Creating a WebApi Project in Visual Studio:

Step 1: Run Visual studio on your machine and click on New Project.

Step 2: The below dialog box appears, click on Web under Visual C# tab –> ASP.NET Web Application –> Give the name of the project –> OK.

Step 3: Select the WebApi option and click on OK.

Step 4: Create the Database and Insert some sample data using the following SQL script.

CREATE TABLE [dbo].[Product] (
    [Id]       INT           IDENTITY (1, 1) NOT NULL,
    [Name]     VARCHAR (100) NOT NULL,
    [Price]    INT           NOT NULL,
    [Category] VARCHAR (100) NOT NULL,
    PRIMARY KEY CLUSTERED ([Id] ASC)
)
 
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (1, N'Mobile', 500, N'Electronics')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (2, N'Tablet', 700, N'Electronics')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (3, N'Mouse', 200, N'Electronics')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (4, N'Keyboard', 340, N'Electronics')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (5, N'Speakers', 5000, N'Electronics')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (6, N'T-Shirts', 100, N'Wearables')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (7, N'Pants', 120, N'Wearables')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (8, N'Jeans', 540, N'Wearables')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (9, N'Chips', 50, N'Eatables')
INSERT INTO [dbo].[Product] ([Id], [Name], [Price], [Category]) VALUES (10, N'Coke', 30, N'Eatables')

The final table will be like below.

Now we need to do all the CRUD operations on the above table and data.

Step 5: Create a Class Library project that connects to database and provide us with the required classes and properties using ADO.NET Entity framework.

Step 6: After clicking on Finish Button, you will see the below EDMX file showing the data-entity relationship as defined in database.

Now, we are done with the connectivity to Database.

Step 7: Now, we need to add the reference of the above created project in our Web Api project, so follow the below steps.

Step 8: Now we need to create a new ProductsController.cs file in the Controllers folder of WebApi Project. This file will contain the methods that corresponds to HTTP verbs that we discussed in the very begining of this tutorial.

Step 9: Add the following code to the ProductsController.cs.

public ProductEntities Entities = new ProductEntities();
 
        public HttpResponseMessage Get()
        {
            try
            {
                return Request.CreateResponse(HttpStatusCode.Found, Entities.Products.ToList());
            }
            catch (Exception)
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, "No Data found");
            }
        }
 
        public HttpResponseMessage Get(int id)
        {
            try
            {
                return Request.CreateResponse(HttpStatusCode.Found, Entities.Products.SingleOrDefault(p => p.Id == id));
            }
            catch (Exception)
            {
                return Request.CreateErrorResponse(HttpStatusCode.NotFound, "No Data found");
            }
        }
 
        public HttpResponseMessage Post([FromBody] Product product)
        {
            try
            {
                Entities.Products.Add(product);
                Entities.SaveChanges();
                var response = Request.CreateResponse(HttpStatusCode.Created, product);
                response.Headers.Location = Request.RequestUri;
 
                return response;
            }
            catch (Exception)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Data not inserted");
            }
        }
 
        public HttpResponseMessage Delete(int id)
        {
            try
            {
                var product = Entities.Products.SingleOrDefault(p => p.Id == id);
                if (product == null)
                    return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Product not found to delete");
                Entities.Products.Remove(product);
                Entities.SaveChanges();
 
                return Request.CreateResponse(HttpStatusCode.OK, "Product Deleted Successfully");
            }
            catch (Exception)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Product not deleted");
            }
        }
 
        public HttpResponseMessage Put(int id, [FromBody] Product product)
        {
            try
            {
                var entity = Entities.Products.SingleOrDefault(p => p.Id == id);
                if (entity == null)
                    return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Product not found ");
 
                entity.Category = product.Category;
                entity.Name = product.Name;
                entity.Price = product.Price;
                Entities.SaveChanges();
 
                return Request.CreateResponse(HttpStatusCode.OK, "Product Updated Successfully");
            }
            catch (Exception ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex);
            }
        }

Step 10: Go to App_Start folder of the root directory and open WebApiConfig.cs file and add the following code of lines.

config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
config.Formatters.Remove(config.Formatters.XmlFormatter);

The above two lines makes the API, only JSON supported. So, by default, now our API will support only JSON Media type format.

Now, our API is ready. Just add the below connection string to the API’s web.config file.

<add name="ProductEntities"
connectionString="metadata=res://*/ProductsModel.csdl|res://*/ProductsModel.ssdl|res://*/ProductsModel.msl;
provider=System.Data.SqlClient;provider connection string="
data source=(local);initial catalog=DemoDB;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework""
providerName="System.Data.EntityClient" />

Press Ctrl + F5 and navigate to http://localhost:26317/api/products. You will see the details of product table in JSON format as below.

Now, as per the Agenda of this article, we will install Fiddler tool and Postman tool to test the API functionality.

Using Fiddler to test Web Api

Step 1: Download the fiddler from the below url and as shown in the screenshot.

Install the downloaded exe file and run it.

Step 2: First we will check the GET functionality. So, follow the steps shown in screenshot below and you will get the result in JSON format.

fiddlerdel1

Step 2: Now we will test POST (Insert) functionality.

Now the data is inserted on 12th row.

Step 3: Now we will update the data on 12th Id using the PUT functionality.

Now, the data is updated successfully.

Step 4: Now we will DELETE the 12th record.

But, using Fiddler to just test the Web Api functionality looks complicated, so instead of using Fiddler, we can use Postman (Google Chrome Extension).

Using Postman to test Web Api

Step 1: Install Postman App in Google Chrome browser as shown below.

Step 2: Run Postman app from the Apps option in Google chrome browser. So, now testing the GET Functionality.

Step 3: Testing the POST functionality.

So, the record is inserted at 13th row.

Step 4: Testing the PUT functionality.

So, data updated in Database.

Step 5: Finally test the Delete functionality.

Conclusion: Personally, I feel using Postman to test Web Api’s and WCF services. We can also use fiddler, but if the API is too complex, so I recommend to use Fiddler as it gives more flexibility to test the services.

Hope you liked the above tutorial. If so, do comment with your compliments and queries. I will try to reply ASAP.