Information System Project on Martin’s Supermarket System

Purpose Statement

As presented in my Final Project Proposal (FPP) dated 04 Nov 2010, I am writing a Project Progress Report (PPR) based on Martin’s Retail Supermarket system, in this context referred to as the Retail online Management System (RoSM). The progress report will determine whether a more in-depth analysis and feasibility studies are required or if more time should be channeled into the development of this system.

As of now, the problem domain has been established, preliminary feasibility studies have been carried out successfully, detailed research into various activities has commenced and a timetable to meet the project completion deadline has been established.

On October 22^nd, project development commenced with a clear objective of making a system that was robust and flexible enough to capture the needs of its intended recipients.

Background

The supermarket is jointly owned by two partners and they have both reserved their compliments to the proposed system because it will raise their investments to greater heights. The store uses manual book-keeping records which slow down operations and inflate the cost of business.

Located in Brentford, West London, the store was opened on March 21, 2006. The other branch is in Isleworth. They can both take advantage of the technological advances in the 21^st century to attract more customers and effectively streamline their operations to be harmonized in one central location.

Scope and Objectives

Scope

Having seen the long queues at Martin’s retail supermarket, I thought it was necessary to approach the shop’s managers and offer a long-term solution. I was awestruck when I was informed that all records pertaining to the daily running of the supermarket are reconciled manually by paper and calculators! An agreement was thus made to tackle these problems through the application of technology systems.

Objectives

Upon a thorough inspection of the store, it was found necessary to have an integrated system that captures all the information required and fulfills the requisite requirements of the users.

These objectives are summed up as

1. To provide an interface through which staff and customers can be able to navigate easily without any distraction or difficulties.
2. Design an effective database that is secure and robust enough to capture and retrieve required data within the shortest span of time possible.
3. To produce an effective method of producing reports from all spheres of the supermarket’s operations. This could be in sales, inventory control customer profiles, future payments etcetera.
4. To provide a reliable mechanism to track employees’ work done in relation to a predefined timetable
5. To provide a quick mechanism for suppliers to access their profile and check the availability of pending orders and supply them if need be.
6. Most importantly, to have a web presence for online shopping.

System requirements

This system is being implemented through the Client-Server architecture.

On the server, the software requirements are to have the platform running on a Windows operating system, IIS manager and SQL server. Hardware required will include a processor with a frequency of above 2.0 GHz, minimum memory of 1 GB and a network card of 1001000 MB.

On the client machine, subtle requirements are imposed since the processing is done on the server-side. Only a browser is needed to access and use the system.

Functional requirements of RoSM

The RoSM project has been designed to cater to three groups, as has been detailed in the following section.

Administrators of the store will have a section that will contain all the administrative tools that will greatly aid in the general upkeep and order of the system.

Suppliers will have access to their delivery history and a record of goods they are required to deliver. It is only them together with the administrators that can access this.

The last group includes the shopping level that exclusively deals with the supermarket’s customers. This is being designed to allow the customers to log in and access the goods on sale and possibly purchase them.

Non- functional requirements of RoSM

The system is designed for Martin’s supermarket is meant to focus on

1. Interoperability the system will integrate seamlessly with the existing infrastructure available at the store.
2. Effectiveness This will provide timely information to the end-user while providing impeccable services.
3. Efficiency: instant feedback will be adopted as the norm and users will not have to wait for processing.
4. Flexibility: The system can be used by anyone anywhere in the globe as long as they are online and provide these timely services as if you were physically at the supermarket.
5. Scalability: This will provide the managers of the store with the ability to add more resources to the system as the load increases. By making the system to be web-based, the administrators can now easily update the system with no downtime.
6. User Friendliness: the overall system is designed to have an aesthetic appeal to the end-users and promote more adoption of the portal.

Schedule

This project was initiated in the year 2010 and continues through the year 2011. It is anticipated that by 5^th May 2011, all objectives will have been met and the final solution rolled out. For the complete timetable used, please refer to the first appendix for the Gantt chart (Appendix 1).

Methodology and Techniques

Overview

To effectively tackle the issue of delivering objectives and activities on time, an effective method of managing the work schedule in addition to other iterations is needed. To do this, I proposed the use of the Dynamic Systems Development Method (DSDM) in my project proposal. DSDM is a software development approach that is incorporated within the ideas of Rapid Application Development (RAD).

Methodology

Principles of DSDM

Dynamic Systems Development Method comprises nine primary principles that guide its implementation. They are given below in relation to the intended project, RoSM.

1. All stakeholders involved in RoSM must work collectively as a team in order to arrive at accurate decisions.
2. Everyone who has a stake in the project development should take responsibility for his line of work and not wait for higher approval
3. The project should be done in stages or modules. This is to enable the system users together with my supervisor the ability to test and monitor progress as it is made in order to arrest any triviality and make any necessary improvements.
4. All collective activities in making RoSM must be directed at solving critical problems affecting the store rather than a general approach to other systems.
5. Development of RoSM should be done step by step in an incremental manner depending on the feedback given by the store’s owners together with my lecturer.
6. Any changes made within the development cycle in making this system are completely reversible.
7. Preliminary studies and objectives should be identified before the development of the RoSM can start. This is to discourage last-minute deviations that could jeopardize the scope of the project.
8. Testing should be done throughout the RoSM life cycle in order to find and correct any possible bugs.
9. To deliver RoSM on time and make it an effective and efficient solution to the supermarket’s problems, collaborations between me, Martin’s store owners and my lecturer are of the utmost importance in order to have a seamless communication mechanism.

Prerequisites for using DSDM

The Dynamic Systems Development Method registers different success rates depending on the way it is used. For the method to be successful in implementing RoSM, there needs to be high-level interaction between me and the supermarket’s staff that will use the final product. This will address any fatal errors of development before it escalates.

To enable proper system management, I divided the project development into smaller parts. This was done to facilitate an iterative project management approach so I could work simultaneously on two things and then append them together later.

Project life-cycle

Three phases are used to describe the Dynamic Systems Development Method in system development. They are sequentially arranged from the pre-project, project life-cycle and post-project phases as described below onwards.

Phase 1 – The Pre-Project

This phase deals with the variables that precede product development. They are important to realize project funding and ensure commitment throughout the development cycle.

As contained in the FPP, the primary goal and purpose of this project are to come up with a system that will effectively tackle the problems faced by Martins’s retail supermarkets. The owners of the supermarket have expressed their willingness to facilitate any requirements in order to make it a reality. They will handle all financial constraints in the budget and as such my undertakings are to only come up with the system. They have committed themselves to having this solution in their stores because they are losing big opportunities due to the lack of system integration in their current IT setup.

Expected Outcomes

The system should hold all the required information pertaining to the store’s upkeep. This should include details of purchases, orders, employee activities and inventory records.

The performance of RoSM will mainly depend on the hardware installed. The more powerful the servers, the more reliably the system will perform. This is attributed to the fact that on the client, the system runs solely on the browser and thus all its backend processing must be done by the webserver. The server will process the required information upon request and send it to the client’s browser for viewing.

The Client

The two partners of the supermarket serve as the clients of this system. To effectively use the system, they must meet the following requirements:

1. They must use the system for its intended purpose, i.e. retail business
2. The staff of the supermarket has to be trained to effectively use the system
3. The customers of the supermarket need to be made aware of the new system so that they can use it.

Questions that I asked the client included such things as the preferred platform, proposed uses of the system, estimated users of the system and so on. For a sample of the questionnaire used, please refer to appendix 2.

These questions were asked to get more details of the intended project. The clients had the experience of having dealt with the store’s customers and so they knew their exact expectations. I also needed to know the scope of what they needed the system for hence getting to understand how well I could add value to their money.

Follow-up questions were useful in order to determine whether there were any changes in the way the clients needed to have the system developed. If the client had changed his mind about a certain feature of the system, this would be a good opportunity for them to review it and give me back their feedback. The other importance of having done follow-up questions was also as a form of reassuring the clients that progress was being made and giving them an opportunity of reviewing that progress.

Phase 2 – The Project life-cycle

This phase is the most ornate of the three. It details five stages that form a step-by-step system approach. These stages are expounded in great detail below.

Stage 1A: The Feasibility Study

This stage addresses the prerequisites of the methodology to examine the suitability of using DSDM.

Feasibility studies were carried out between the months of October and November 2010 to ascertain whether the proposed system could meet the business needs of Martin’s supermarkets. Preliminary findings yielded positive results that were in favor of the system development. Further studies were conducted to measure the effectiveness of an online solution as opposed to a desktop application. All indicators were in support of the online system because it allowed for a multi-user environment without being tethered to the office. Anyone could access the supermarket’s inventory and thus make orders. A decision was then made to make the proposed system as it was originally envisaged in the FPP.

After having satisfied the business owners that the system could be delivered, another feasibility study was done to find the effectiveness of using a DSDM to manage the project. This too received a boost when I realized that it was indeed a perfect solution to my needs because the DSDM captures all my expectations and offers water-tight management controls from start to finish.

The biggest risks that were found most likely in the development of this system were poor time management skills and haphazard implementation. Time was is of the essence and as such the schedules have to be adhered to while at the same time making sure that the system is properly implemented as agreed with all relevant stakeholders involved.

Stage 1B: The Business Study

This stage examines all the stakeholders involved together with their requirements. To enhance the communication of the different people who were involved, constant meetings were held to discuss all imperative proposals.

The key deliverables were outlined and marked as priority items that had to be delivered within strict timelines. This necessitated the use of Timeboxing techniques that enabled me to split the project into manageable portions each with its own deadline and budget. The split functional requirements can be seen from the Microsoft project Gantt chart later on.

It was agreed that the system would incorporate client-server architecture in order to facilitate the centralization of data. The system would first and foremost address the internal needs of the supermarket such as harmonizing accounts, reconciling returns, making profit and loss statements, facilitating accurate staff payroll, inventory records etcetera. After proper mechanisms have been put in place to enhance security, external access would be facilitated to provide customers and suppliers with an online portal from which they can shop and supply items respectively.

The high-level activities were identified as the parts that the users would interact with most. These are areas such as the graphical user interfaces and login systems. The other less prioritized tasks included the speed of the system as it was agreed functionality was more important. Users of the system would include the staff, customers and suppliers. These three components would comprise different roles and permissions so as to differentiate themselves in the system.

The system will open up the market by introducing online shopping and inventory control. This means that customers can now place orders at the comfort of their own houses while suppliers could check to see if their supplies are running low and resupply again. The suppliers could also log in to the system and access their payment records instead of waiting for checks.

Business processes affected would include almost all operations as they would now be centralized in the system. Supermarket employees would now be paid according to their activity shown in the system, customers can now be able to track their cart history, and suppliers can now tell what products are selling better.

The search for a suitable Integrated Development Environment (IDE) that would be used to make all this become a reality was identified to be Microsoft visual web developer 2008 and visual studio 2008.

Stage 2: Functional Model Iteration

This model continues further with the high-level deliverables captured in the business study above.

The development phase process includes the Functional requirements below:

1. Designing the user interface,
2. Designing the controls on the main interface,
3. Designing and creating the database,
4. Designing the login system,
5. Create roles and groups,
6. Design all other required forms and web pages,
7. Assign permissions to create forms based on roles and groups,
8. Test database connections,
9. Create data integrity constraints,
10. Create relationships in the database and enforce constraints,
11. Customize the interface using Cascading Style Sheets (CSS),
12. Internal testing of the whole system,
13. Deploying the website to a web server for hosting.

As the primary mode of interacting with the system, it was apparent that the interface of the system should be as intuitive and user-friendly as possible to facilitate easier navigation. A model was thus constructed that allowed the users to move from one section to another without getting lost. This was scheduled to take about three days. The interface was designed as per the schedule and tested. The store owners were given a screenshot of how the interface would look like and they gave me the go-ahead to implement it in full.

Creating the database was one of the main activities in the project development. Without it, the functionality of the system was nil. It was evident that the needs of the supermarket would keep on growing and thus high normalization features were required in order to make the tables relevant. I thus arrived at the conclusion that each independent feature of the system should have its own table and then be linked to its child nodes through enforced relationships. All the necessary tables were visualized and then created. This activity took about 2 days and ended on 24^th October 2010. Care was taken to conform to the various data types when creating the tables. Tests were done to find out if the correct data types were entered; e.g. ‘DateTime’ for dates or ‘nvarchar’ for strings.

The most time-consuming activity had to be the creation of all the forms being used in the system. This lasted for approximately one and a half weeks from 22^nd October 2010 to 2^nd November 2010. They were all designed in ASP.NET and AJAX.

They were tested as they were being made which meant that I overlapped the time it took by half. This hastened my schedule for a good measure. I was thus able to move to other areas.

Security played a key integral part in the project life-cycle development. Nothing could be left to chance. If the security failed, hackers could steal credit card information and impersonate themselves through the customer’s identities. Creating this module proved to be quite simple as the ASP.NET framework has the built-in functionality to do this. This was achieved by using the ‘Membership provider’ that is available to systems using Microsoft SQL Server 2005 and above. The information stored was very secure as the passwords created were encrypted using a one-way 256-bit Hash algorithm that cannot be reversed. The complete prototype was completed on 26^th October 2010. It worked accurately and it could reference the logged-in user from any page across the website.

Stage 3: Design and Build Iteration

All the finished prototypes from the functional model iteration were brought together for unification and combined through hyperlinks across the website. The database links were defined by a common connection string stored at the root folder which made my connections fast. This file is referred to as ‘web.config’. It stores the SQL instance name, username and password. This meant that I was not required to constantly call the location and instance of the SQL provider I was using inside the multiple pages I was using. For more details on the ‘web.config’ refer to appendix 4.

The finished prototypes were thoroughly tested and passed the level of completion in my own opinion.

Stage 4: Implementation

The completed system will then be taken to the clients and they will be given training on how to use it. The employees at the supermarket will be most ecstatic about using it because it will make their work easier. The pending requirement is hosting it so that it can be available on the internet but that will be the last step as more testing should be carried out.

At the time of writing this report, I would say that the system captures 80% of the business that needs to be envisioned in the project proposal.

Phase 3 – Post-project

High level of maintenance is needed to make the system bug-free and to make it operate at the intended level. Refinements hare and there are necessary in order to remove any future problems that could affect the system.

Justification of using DSDM

The Dynamic Systems Development Method is mainly based on projects in information systems. This makes it a valuable tool to my work progress and thus important in evaluating work done and scheduling pending assignments. Being a rapid application development, Visual Basic.NET falls under the list of best applications to be monitored under DSDM.

DSDM also allows projects to be delivered on time and on budget while at the same time being flexible to allow for any desired changes in the course of development because of its agility.

Other approaches to system development methods include but are not limited to Rapid Application Development methods (RAD), Object-Oriented methods, structured methods, Extreme Programming (XP) and Rational Unified Process. Most of these had similarities to DSDM but DSDM stood out because of its approach to budget and time management agility.

Software and Tools used

As stated earlier in my project proposal, I opted to use Microsoft’s solution products that included ASP.NET, Visual Studio 2008 and SQL Server 2005. These tools are widely known and as such, their customer support base is very wide. This would mean that in case of any product troubleshooting, ample help would be forthcoming as opposed to other products that are still being adopted.

ASP.NET is a server-side language that gives the web platform a more flexible and powerful means of achieving high objectives. An update to the web interface would be reflected in the web browsers on the net refresh without installing or updating anything on the client machines. It is instant and very efficient compared to desktop tools.

The easy-to-use interface of Microsoft SQL makes it a better-suited candidate compared to other open-source products like MySQL. This means there is more productivity in the development stages because I am able to navigate easily via the IDE.

I was able to separate the design and logic of the project into two thanks to the ability of ASP.NET to have two separate files working together as one. One of the files contains the code that makes up the interface and controls of the form while the other file has all the logic back-end code that runs the instructions passed from the page. This functionality made it easier for me to focus on one task at a time as opposed to using openly licensed tools as PHP which combines all these functions into one page making the code look bulky and unmanageable. For a detailed look at these two separate files, please see appendix 3a and 3b.

Issues related to project management

As I progressed in making this system, I soon realized that making the proposals and implementing them were two different things altogether. I had anticipated major shifts in the way the supermarket conducted its business but I had to fit in the solutions to work with the exiting business model.

In one of the objectives, I wanted to have a system that would be able to capture the inputs of every employee and calculate their returns from it. That was not found to be possible because the system does most of the work unmanaged. There is thus no way to attribute the work done to a particular employee. Customers can make orders online and thus no employee has participated in the transaction to warrant any pay. This problem was found to be major and the only mechanism to evaluate the staff’s input was to check their account activities. If a user account was more active than the others, it meant that employee was thus working more. It was not as precise as needed but it did the trick.

Organizing research was easy because of the amicable solutions offered by DSDM in managing projects. I was able to effectively organize my work and conduct studies in the field as I progressed implementing the project’s prototypes. Getting the necessary literature to use as my aid has not been a problem because project management is a broad field and a lot of people have invested their time in coming up with resources that addresses almost all the concerns I have met so far.

There are clear communication channels between me and the supermarkets managers so I always have the latest updates on how they want to have the system developed. We communicate mostly face to face so that we can have adequate feedback.

The major concern I am experiencing in this project’s implementation is meeting laid down deadlines. I manage this by using a Gantt chart I made that displays my schedule. The trouble with this is that some sections like the design of the forms have taken more time than planned for hence affecting the performance of other sections.

Conclusion

From my own experience, supervised work promotes more growth in the way projects are handled because it gives students a helping hand in knowing how to approach the subject. Trying to defuse the problem domain becomes relatively easier when you have a concise methodology taught by the supervisor. Managing projects in the absence of such methodologies can result in many obstacles and as such I feel it is highly important to be supervised while doing projects.

Another notable merit of supervision while carrying out research and project development is being made to meet laid down deadlines. This promotes unison in the research methodologies and makes the students focus on the deliverables. In the absence of such deadlines, projects would take eternity to complete.

References

Bentley, L. & Whitten, J., 2007. System Analysis & Design for the Global Enterprise. 7^th ed. Boston, MA : Thomson Course Technology.

Blanchard, B. & Fabrycky, W., 2006. Systems engineering and analysis. 4^th ed. New Jersey: Prentice Hall.

Cristian, D. & Zak, R., 2006. ASP.NET 2.0: A Getting Started Guide. Melbourne: SitePoint.

Cunliffe, B., 1999. System Analysis & Design for the Global Enterprise. Harmondsworth: Penguin Books.

Michele, B., 2008. Initiating Phase – Feasibility Study Request and Report. Brisbane: Queensland University of Technology. Web.

Rajesh, N., 2004. Database Management Systems. New Delhi: Prentice-Hall of India, Pvt. Ltd.

Wiegers, E., 2003. Software Requirements. 2^nd ed. Redmond, WA: Microsoft Press.

Soothill, K., 2003. SQL Software. Cambridge: polity press.

Todd, M., 2008. Database Management Systems. London: Fontana Press.

Zak, R., 2009. Software Requirements. Melbourne: SitePoint.

Appendices

Appendix 2: Questionnaire

Appendix 3a- ASP.NET Design code (Front-End):

Appendix 3b- ASP.NET Logic code (Backend):

Imports System.Data
Imports System.Data.SqlClient
Partial Class Transactions_Customers_NewOrders
    Inherits System.Web.UI.Page
    Dim strConn As String = ConfigurationManager.ConnectionStrings(“ApplicationServices”).ConnectionString
    Dim con As SqlConnection
    Dim cmd As New SqlCommand()
    Protected Sub DepartmentDropDownList_SelectedIndexChanged(ByVal sender As Object, ByVal e As EventArgs)
        Dim CountryID As Integer = Convert.ToInt32(DepartmentDropDownList.SelectedValue.ToString())
        FillProducts(CountryID)
        ProductDropDownList.Enabled = True
    End Sub
    Private Sub FillProducts(ByVal countryID As Integer)
        con = New SqlConnection(strConn)
        cmd.Connection = con
        cmd.CommandType = CommandType.Text
        cmd.CommandText = “Select ProductID, ProductName, SellingPrice from Products where DepartmentID =@DepartmentID”
        cmd.Parameters.AddWithValue(“@DepartmentID”, countryID)
        Dim objDs As New DataSet()
        Dim dAdapter As New SqlDataAdapter()
        dAdapter.SelectCommand = cmd
        con.Open()
        dAdapter.Fill(objDs)
        con.Close()
        If objDs.Tables(0).Rows.Count > 0 Then
            ProductDropDownList.DataSource = objDs.Tables(0)
            ProductDropDownList.DataTextField = “ProductName”
            ProductDropDownList.DataValueField = “ProductID”
            ProductDropDownList.DataBind()
            ProductDropDownList.Items.Insert(0, “[Select One]”)
        Else
            lblMsg.Text = “No states found”
        End If
    End Sub
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        ProductDropDownList.Enabled = False
        AddToList.Enabled = False
    End Sub
    Protected Sub CheckOut_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles CheckOut.Click
        Page.Response.Redirect(“~/Processing/Checkout.aspx”)
    End Sub
    Protected Sub AddToList_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles AddToList.Click
        ProductDropDownList.Enabled = True
        Using myConnection As New SqlConnection(ConfigurationManager.ConnectionStrings(“ApplicationServices”).ConnectionString)
            Const ContactDetails As String = “INSERT INTO [Order] ([CustomerID],[Date], [ProductName])” & _
                                                      “VALUES (@CustomerID, @Date, @ProductName)”
            Dim ContactDetailsCommand As New SqlCommand(ContactDetails, myConnection)
            ContactDetailsCommand.Parameters.AddWithValue(“@CustomerID”, CustomerIDtxt.Text.Trim())
            ContactDetailsCommand.Parameters.AddWithValue(“@Date”, DateTime.Now)
            ContactDetailsCommand.Parameters.AddWithValue(“@ProductName”, ProductDropDownList.SelectedItem.Text)
            myConnection.Open()
            ContactDetailsCommand.ExecuteNonQuery()
            myConnection.Close()
            Page.Response.Redirect(“~/Transactions/Customers/NewOrders.aspx”)
        End Using
    End Sub
    Protected Sub ProductDropDownList_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles ProductDropDownList.SelectedIndexChanged
        AddToList.Enabled = True
        ProductDropDownList.Enabled = True
    End Sub
End Class

Appendix 4

<?xml version=“1.0“?>
<!–
  For more information on how to configure your ASP.NET application, please visit
  http://go.microsoft.com/fwlink/?LinkId=169433
  –>
<configuration>
<configSections>
<sectionGroup name=“system.web.extensions“ type=“System.Web.Configuration.SystemWebExtensionsSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“>
<sectionGroup name=“scripting“ type=“System.Web.Configuration.ScriptingSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“>
<section name=“scriptResourceHandler“ type=“System.Web.Configuration.ScriptingScriptResourceHandlerSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“ requirePermission=“false“ allowDefinition=“MachineToApplication“/>
<sectionGroup name=“webServices“ type=“System.Web.Configuration.ScriptingWebServicesSectionGroup, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“>
<section name=“jsonSerialization“ type=“System.Web.Configuration.ScriptingJsonSerializationSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“ requirePermission=“false“ allowDefinition=“Everywhere“/>
<section name=“profileService“ type=“System.Web.Configuration.ScriptingProfileServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“ requirePermission=“false“ allowDefinition=“MachineToApplication“/>
<section name=“authenticationService“ type=“System.Web.Configuration.ScriptingAuthenticationServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“ requirePermission=“false“ allowDefinition=“MachineToApplication“/>
<section name=“roleService“ type=“System.Web.Configuration.ScriptingRoleServiceSection, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“ requirePermission=“false“ allowDefinition=“MachineToApplication“/></sectionGroup></sectionGroup></sectionGroup></configSections>
  <connectionStrings>
<add name=“ApplicationServices“ connectionString=“data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|\aspnetdb.mdf;User Instance=true“ providerName=“System.Data.SqlClient“/>
          </connectionStrings>
<system.web>
<compilation debug=“true“ strict=“false“ explicit=“true“ >
<assemblies>
<add assembly=“System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089“/>
<add assembly=“System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add assembly=“System.Xml.Linq, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089“/>
<add assembly=“System.Data.DataSetExtensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089“/></assemblies></compilation>
<authentication mode=“Forms“>
<forms loginUrl=“~/Account/Login.aspx“ timeout=“2880“/>
</authentication>
<membership>
<providers>
<clear/>
<add name=“AspNetSqlMembershipProvider“ type=“System.Web.Security.SqlMembershipProvider“ connectionStringName=“ApplicationServices“ enablePasswordRetrieval=“false“ enablePasswordReset=“true“ requiresQuestionAndAnswer=“false“ requiresUniqueEmail=“false“ maxInvalidPasswordAttempts=“5“ minRequiredPasswordLength=“6“ minRequiredNonalphanumericCharacters=“0“ passwordAttemptWindow=“10“ applicationName=“/“/>
</providers>
</membership>
<profile>
<providers>
<clear/>
<add name=“AspNetSqlProfileProvider“ type=“System.Web.Profile.SqlProfileProvider“ connectionStringName=“ApplicationServices“ applicationName=“/“/>
</providers>
</profile>
<roleManager enabled=“true“>
   <providers>
    <clear />
    <add connectionStringName=“ApplicationServices“ applicationName=“/“
     name=“AspNetSqlRoleProvider“ type=“System.Web.Security.SqlRoleProvider“ />
    <add applicationName=“/“ name=“AspNetWindowsTokenRoleProvider“
     type=“System.Web.Security.WindowsTokenRoleProvider“ />
   </providers>
  </roleManager>
<pages>
<controls>
<add tagPrefix=“asp“ namespace=“System.Web.UI“ assembly=“System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add tagPrefix=“asp“ namespace=“System.Web.UI.WebControls“ assembly=“System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/></controls></pages>
<httpHandlers>
<remove verb=“*“ path=“*.asmx“/>
<add verb=“*“ path=“*.asmx“ validate=“false“ type=“System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add verb=“*“ path=“*_AppService.axd“ validate=“false“ type=“System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add verb=“GET,HEAD“ path=“ScriptResource.axd“ validate=“false“ type=“System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/></httpHandlers>
<httpModules>
<add name=“ScriptModule“ type=“System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/></httpModules></system.web>
<system.webServer>
<modules runAllManagedModulesForAllRequests=“true“>
<remove name=“ScriptModule“/>
<add name=“ScriptModule“ preCondition=“managedHandler“ type=“System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/></modules>
<validation validateIntegratedModeConfiguration=“false“/>
<handlers>
<remove name=“WebServiceHandlerFactory-Integrated“/>
<remove name=“ScriptHandlerFactory“/>
<remove name=“ScriptHandlerFactoryAppServices“/>
<remove name=“ScriptResource“/>
<add name=“ScriptHandlerFactory“ verb=“*“ path=“*.asmx“ preCondition=“integratedMode“ type=“System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add name=“ScriptHandlerFactoryAppServices“ verb=“*“ path=“*_AppService.axd“ preCondition=“integratedMode“ type=“System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/>
<add name=“ScriptResource“ verb=“GET,HEAD“ path=“ScriptResource.axd“ preCondition=“integratedMode“ type=“System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35“/></handlers></system.webServer>
<system.codedom>
<compilers>
<compiler language=“c#;cs;csharp“ extension=“.cs“ type=“Microsoft.CSharp.CSharpCodeProvider,System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089“ warningLevel=“4“>
<providerOption name=“CompilerVersion“ value=“v3.5“/>
<providerOption name=“WarnAsError“ value=“false“/></compiler>
<compiler language=“vb;vbs;visualbasic;vbscript“ extension=“.vb“ type=“Microsoft.VisualBasic.VBCodeProvider, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089“ warningLevel=“4“>
<providerOption name=“CompilerVersion“ value=“v3.5“/>
<providerOption name=“OptionInfer“ value=“true“/>
<providerOption name=“WarnAsError“ value=“false“/></compiler></compilers></system.codedom>
<runtime>
<assemblyBinding xmlns=“urn:schemas-microsoft-com:asm.v1“>
<dependentAssembly>
<assemblyIdentity name=“System.Web.Extensions“ publicKeyToken=“31bf3856ad364e35“/>
<bindingRedirect oldVersion=“1.0.0.0-1.1.0.0“ newVersion=“3.5.0.0“/></dependentAssembly>
<dependentAssembly>
<assemblyIdentity name=“System.Web.Extensions.Design“ publicKeyToken=“31bf3856ad364e35“/>
<bindingRedirect oldVersion=“1.0.0.0-1.1.0.0“ newVersion=“3.5.0.0“/></dependentAssembly></assemblyBinding></runtime></configuration>

Appendix 5

Prototypes of finished work