LG Optimus One LGP500H installing usb driver (Koodoo phone Canada)

Taswar Bhatti March 18, 2011 26 Comments

So Koodoo is having a deal on android phone LG Optimus One LGP500H and I couldnt resist and picked one up and unlocked it and wanted to start development on it. So here are some steps on LG Optimus One LGP500H installing usb driver.

So my first step is to get the USB driver working on my win7 machine.
I went to LG and downloaded their Mobile Support Tool to PC from http://www.lg.com/ca_en/support/product/support-product-profile-mobile-redux.jsp?customerModelCode=LGP500H&initialTab=drivers&targetPage=support-product-profile-mobile-redux

Once downloaded I launched the app.
Here is a step by step instructions of it.

One has to click on the Install USB Driver (yeah I know it looks grey out but one can click on it)

Next select the model of your phone and double click, which is LGP500H for us.

Then it will launch the install of the driver and select English

Click Next

And you will next see that the install is successful.

Now you can plug in your phone and it should try to update it but since its update to date there is nothing to install optionally one can install the mobile sync app and manual.

Hope this helps 🙂

Android

android, LG Optimus One, mobile

Automapper: Mapping Objects Part 7 of 7 (Startup Registration)

Taswar Bhatti March 15, 2011 3 Comments

In this last part of the series I wanted to talk about how to register automapper at startup of your web application, in doing so it would help speed things up with automapper.

There are many ways to do it, the easiest way is to just have a method inside Global.asax.cs file in your Application_Start like below

 protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);
            RegisterAutoMapper();                       
        }

        private static void RegisterAutoMapper()
        {
            Mapper.CreateMap<Order, OrderDateDto>()
             .ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))
             .ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));

          //rest of the mapping
        }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

protected void Application_Start()

{

AreaRegistration.RegisterAllAreas();

RegisterGlobalFilters(GlobalFilters.Filters);

RegisterRoutes(RouteTable.Routes);

RegisterAutoMapper();

}

private static void RegisterAutoMapper()

{

Mapper.CreateMap<Order, OrderDateDto>()

.ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))

.ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));

//rest of the mapping

}

And if you are using an IoC container, than one can use the Command Pattern for a StartupTask, below is an example of using ServiceLocator for startup.

 protected void Application_Start()
 {
      Startup.Run();            
 }

public class Startup 
{
     public static void Run()
     {
            var startupTask = ServiceLocator.Current.GetAllInstances<IStartupTask>();

            foreach (var task in startupTask)
            {
                task.Execute();
            }
        }
}

public interface IStartupTask
{
        void Execute();
}

 public class AutoMapperStartupTask: IStartupTask
 {      
        public void Execute()
        {
              Mapper.CreateMap<Order, OrderDateDto>()
             .ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))
             .ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));
            //rest of mapping code
         }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

protected void Application_Start()

{

Startup.Run();

}

public class Startup

{

public static void Run()

{

var startupTask = ServiceLocator.Current.GetAllInstances<IStartupTask>();

foreach (var task in startupTask)

{

task.Execute();

}

public interface IStartupTask

{

void Execute();

}

public class AutoMapperStartupTask: IStartupTask

{

public void Execute()

{

Mapper.CreateMap<Order, OrderDateDto>()

.ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))

.ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));

//rest of mapping code

}

Note: one will need to remove all the CreateMap code in their controller to here, you do not need to call CreateMap anymore since the startup task takes care of it.

This concludes our final segment on Automapper, hopefully you will find this helpful 😛

Previous Post:
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)
Part 4 (Projection)
Part 5 (CustomResolver)
Part 6 (CustomFormatter)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 6 of 7 (CustomFormatter)

Taswar Bhatti March 14, 2011 3 Comments

In this part I will show how we can use a customer value formatter (CustomFormatter) to format our mapped data into single “Number of Order:” and plural “Number of Orders:”.

First the Domain and Dto (data transfer object)

//Domain
public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//Dto
public class NumberOfOrderDto
    {
        public string CustomerName { get; set; }
        public string NumberOfOrders { get; set; }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

//Domain

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//Dto

public class NumberOfOrderDto

{

public string CustomerName { get; set; }

public string NumberOfOrders { get; set; }

}

Now we will introduce a CustomResolver and Formatter, for the Formatter we are inheriting from IValueFormatter

//Resolver
public class CustomOrderCount: ValueResolver<Order, int>
    {
        protected override int ResolveCore(Order source)
        {
            return source.LineItems.Count();
        }
    }

//Formatter
public class FormatOrderCount: IValueFormatter
    {
        public string FormatValue(ResolutionContext context)
        {
            int num = (int)context.SourceValue;

            if (num <= 1)
                return "Number of Order: " + num;

            return "Number of Orders: " + num;
        }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//Resolver

public class CustomOrderCount: ValueResolver<Order, int>

{

protected override int ResolveCore(Order source)

{

return source.LineItems.Count();

}

//Formatter

public class FormatOrderCount: IValueFormatter

{

public string FormatValue(ResolutionContext context)

{

int num = (int)context.SourceValue;

if (num <= 1)

return "Number of Order: " + num;

return "Number of Orders: " + num;

}

For our mapping code we will use a block for options, so that after resolving the value, it would format it.

public ActionResult NumberOfOrders()
        {
            var orders = _respository.GetAll();

            orders.First().LineItems = new List<OrderItems>();

            Mapper.CreateMap<Order, NumberOfOrderDto>()
                .ForMember(dest => dest.NumberOfOrders, opt =>
                                                            {
                                                                opt.ResolveUsing<CustomOrderCount>();
                                                                opt.AddFormatter<FormatOrderCount>();
                                                            });

            var model = Mapper.Map<IEnumerable<Order>, IEnumerable<NumberOfOrderDto>>(orders);

            return View(model);
        }

//View
<h2>NumberOfOrders</h2>

@foreach (var order in Model)
{
    <p>
    @order.CustomerName <br />
    @order.NumberOfOrders <br />
    </p>
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

public ActionResult NumberOfOrders()

{

var orders = _respository.GetAll();

orders.First().LineItems = new List<OrderItems>();

Mapper.CreateMap<Order, NumberOfOrderDto>()

.ForMember(dest => dest.NumberOfOrders, opt =>

{

opt.ResolveUsing<CustomOrderCount>();

opt.AddFormatter<FormatOrderCount>();

});

var model = Mapper.Map<IEnumerable<Order>, IEnumerable<NumberOfOrderDto>>(orders);

return View(model);

}

//View

<h2>NumberOfOrders</h2>

@foreach (var order in Model)

{

<p>

@order.CustomerName <br />

@order.NumberOfOrders <br />

</p>

}

From the view we can see that the first order is displaying Order rather than Orders.

In the last part of the series I will show how to move all your mapping code to startup, so that it would speed things up.

Previous Post
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)
Part 4 (Projection)
Part 5 (CustomResolver)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 5 of 7 (CustomResolver)

Taswar Bhatti March 11, 2011 2 Comments

In Part 5, we will use a powerful feature that automapper allows us, which is CustomResolver.

Lets look at our Domain Object which contains a boolean field called ShipToHomeAddress, what we will do is map those boolean to a string value with “Yes” or “No”.

 public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//DTO
public class OrderShipDto
    {
        public string ShipHome { get; set; }
        public string CustomerName { get; set; }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//DTO

public class OrderShipDto

{

public string ShipHome { get; set; }

public string CustomerName { get; set; }

}

For our mapping code we will introduce CustomResolver class which inherits from ValueResolver and would map the boolean field to string

 public class CustomBoolResolver: ValueResolver<Order, string>
    {
        protected override string ResolveCore(Order source)
        {
            return source.ShipToHomeAddress ? "Yes" : "No";
        }
    }

1

2

3

4

5

6

7

public class CustomBoolResolver: ValueResolver<Order, string>

{

protected override string ResolveCore(Order source)

{

return source.ShipToHomeAddress ? "Yes" : "No";

}

Now our mapping code would look like

 public ActionResult OrderShip()
        {
            var orders = _respository.GetAll();

            Mapper.CreateMap<Order, OrderShipDto>()
                .ForMember(dest => dest.ShipHome, opt => opt.ResolveUsing<CustomBoolResolver>());

            var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderShipDto>>(orders);

            return View(model);
        }

//View
<h2>OrderShip</h2>
<table>
    <tr>        
        <th>Name</th>
        <th>Ship to Home</th>
    </tr>
@foreach (var item in Model)
{
    <tr>       
        <td>@item.CustomerName</td>
        <td>@item.ShipHome</td>
    </tr>
}
 
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

public ActionResult OrderShip()

{

var orders = _respository.GetAll();

Mapper.CreateMap<Order, OrderShipDto>()

.ForMember(dest => dest.ShipHome, opt => opt.ResolveUsing<CustomBoolResolver>());

var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderShipDto>>(orders);

return View(model);

}

//View

<h2>OrderShip</h2>

<table>

<tr>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.CustomerName</td>

<td>@item.ShipHome</td>

</tr>

}

</table>

The end result of the view looks like

In Part6, I will show how to use a CustomerFormatter with a Resolver to format the data in a certain way.

Previous Post:
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)
Part 4 (Projection)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 4 of 7 (Projection)

Taswar Bhatti March 10, 2011 4 Comments

In Part 4 we will see how we can use projection to map inner objects for example a DateTime field.

Again our domain and Dto (Data Transfer Object) looks like

//Order
 public class Order
 {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
 }

//Dto
 public class OrderDateDto
 {        
        public int PurchaseHour { get; set; }
        public int PurchaseMinute { get; set; }
        public string CustomerName { get; set; }     
 }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//Order

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//Dto

public class OrderDateDto

{

public int PurchaseHour { get; set; }

public int PurchaseMinute { get; set; }

public string CustomerName { get; set; }

}

We will map the PurchaseDate in the Domain Object to our Dto PurchaseHour and Purchase Minute.

 public ActionResult OrderDate()
 {
            var order = _respository.Get(3);

            order.PurchaseDate = new DateTime(2011, 3, 15, 20, 30, 0);
            Mapper.CreateMap<Order, OrderDateDto>()
             .ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))
             .ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));
            
            var model = Mapper.Map<Order, OrderDateDto>(order);                

            return View(model);
}
//View
<h2>OrderDate</h2>

@Model.CustomerName @Model.PurchaseHour @Model.PurchaseMinute

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public ActionResult OrderDate()

{

var order = _respository.Get(3);

order.PurchaseDate = new DateTime(2011, 3, 15, 20, 30, 0);

Mapper.CreateMap<Order, OrderDateDto>()

.ForMember(dest => dest.PurchaseHour, opt => opt.MapFrom(src => src.PurchaseDate.Hour))

.ForMember(dest => dest.PurchaseMinute, opt => opt.MapFrom(src => src.PurchaseDate.Minute));

var model = Mapper.Map<Order, OrderDateDto>(order);

return View(model);

}

//View

<h2>OrderDate</h2>

@Model.CustomerName @Model.PurchaseHour @Model.PurchaseMinute

As you can see the View now contains the flatten Hour and Minute, from our previous posting we also see that the other way of nested projection/flattening is by CustomerName.

Here is how our view would display

In part 5, I will show how to use CustomerResolver to resolve and map values to different types.

Previous Post:
Part 1 (NullSubsitution)
Part 2 (Flattening by Convention)
Part 3 (Nested Mapping)

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 3 of 7 (Nested Mapping)

Taswar Bhatti March 9, 2011 11 Comments

In this part we learn about Nested Mapping in Automapper and we will use the same OrderDto Object that we had previously but we will let Automapper to map the inner objects.

Once again here is the Domain Objects First

//Order 
public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//OrderItems
public class OrderItems
    {
        public decimal Price { get; set; }
        public string Name { get; set; }
        public int Quantity { get; set; }
        public decimal GetTotalPrice()
        {
            return Price * Quantity;
        }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

//Order

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//OrderItems

public class OrderItems

{

public decimal Price { get; set; }

public string Name { get; set; }

public int Quantity { get; set; }

public decimal GetTotalPrice()

{

return Price * Quantity;

}

The Dto (Data Transfer Object) look like

public class OrderDto
    {
        public string CustomerName { get; set; }
        public decimal Total { get; set; }
        public string OrderNumber { get; set; }
        public IEnumerable<OrderItemsDto> LineItems { get; set; }
    }

//OrderItemsDto
public class OrderItemsDto
    {
        public string Name { get; set; }
        public int Quantity { get; set; }
        public decimal Price { get; set; }
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

public class OrderDto

{

public string CustomerName { get; set; }

public decimal Total { get; set; }

public string OrderNumber { get; set; }

public IEnumerable<OrderItemsDto> LineItems { get; set; }

}

//OrderItemsDto

public class OrderItemsDto

{

public string Name { get; set; }

public int Quantity { get; set; }

public decimal Price { get; set; }

}

This time when we map Order to OrderDto we will also provide the mapping of OrderItems to OrderItemsDto.

public ActionResult OrderItems()
        {
            var orders = _respository.GetAll();

            Mapper.CreateMap<Order, OrderDto>()
                .ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo));
                
            Mapper.CreateMap<OrderItems, OrderItemsDto>();

            var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

            return View(model);
        }
//View
<table>
    <tr>
        <th>Order Number</th>
        <th>Name</th>
        <th>Total</th>
        <th>Items</th>
    </tr>
@foreach (var item in Model)
{
    <tr>
        <td>@item.OrderNumber</td>
        <td>@item.CustomerName</td>
        <td>$@item.Total</td>
        <td>            
            @foreach (var child in item.LineItems)
            {
                @string.Format("({0}) {1} - ${2}", @child.Quantity, @child.Name, @child.Price)<br />
            }           
       </td>
    </tr>
}
 
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

public ActionResult OrderItems()

{

var orders = _respository.GetAll();

Mapper.CreateMap<Order, OrderDto>()

.ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo));

Mapper.CreateMap<OrderItems, OrderItemsDto>();

var model = Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

return View(model);

}

//View

<table>

<tr>

<th>Order Number</th>

<th>Total</th>

<th>Items</th>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.OrderNumber</td>

<td>@item.CustomerName</td>

<td>$@item.Total</td>

<td>

@foreach (var child in item.LineItems)

{

@string.Format("({0}) {1} - ${2}", @child.Quantity, @child.Name, @child.Price)<br />

}

</td>

</tr>

}

</table>

As you can see I have taught automapper about its inner child/object mapping before calling Map, thus it knows about the inner mapping, our result would show like

In the next part I will be showing projection in Automapper.

Previous Post:
Part 1 NullSubsitution
Part 2 Flattening by Convention

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 2 of 7 (Flattening by Convention)

Taswar Bhatti March 8, 2011 2 Comments

In this part I will be showing how Automapper uses flattening by convention.

If we look at our OrderDto we will see that it has a IEnumerable of OrderItemsDto and also something called OrderNumber. This is the type of object we want to send to our presentation layer.

 public class OrderDto
    {
        public string CustomerName { get; set; }
        public decimal Total { get; set; }
        public string OrderNumber { get; set; }
        public IEnumerable<OrderItemsDto> LineItems { get; set; }
    }

1

2

3

4

5

6

7

public class OrderDto

{

public string CustomerName { get; set; }

public decimal Total { get; set; }

public string OrderNumber { get; set; }

public IEnumerable<OrderItemsDto> LineItems { get; set; }

}

Compare that to our domain object where it has a GetTotal method, OrderNo and a Customer Object

//Domain Object
public class Order
    {
        public string OrderNo { get; set; }
        public Customer Customer { get; set;  }
        public DateTime PurchaseDate { get; set; }
        public IEnumerable<OrderItems> LineItems { get; set; }
        public bool ShipToHomeAddress { get; set; }
        public decimal GetTotal()
        {
            return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());
        }
        public Guid InternalId { get; set; }
    }

//Customer Domain Object
 public class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Bio { get; set; }
        public string GetName()
        {
            return FirstName + ' ' + LastName;
        }       
    }

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

//Domain Object

public class Order

{

public string OrderNo { get; set; }

public Customer Customer { get; set; }

public DateTime PurchaseDate { get; set; }

public IEnumerable<OrderItems> LineItems { get; set; }

public bool ShipToHomeAddress { get; set; }

public decimal GetTotal()

{

return LineItems == null ? 0 : LineItems.Sum(x => x.GetTotalPrice());

}

public Guid InternalId { get; set; }

}

//Customer Domain Object

public class Customer

{

public string FirstName { get; set; }

public string LastName { get; set; }

public string Bio { get; set; }

public string GetName()

{

return FirstName + ' ' + LastName;

}

In Automapper there is a convention where it sees the method has a Get in front it. It will then auto flatten it by convention. See how in the OrderDto I have Total as a property and also CustomerName.

Our mapping code would look something like this where we are mapping OrderNo to OrderNumber

 public ActionResult Index()
        {
            var orders = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Order, OrderDto>()
                .ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo))
                .ForMember(dest => dest.OrderItemsDto, opt => opt.Ignore());

            var model = AutoMapper.Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

            return View(model);
        }
//Razor View Code
<h2>Orders</h2>
<table>
    <tr>
        <th>Order Number</th>
        <th>Name</th>
        <th>Total</th>
    </tr>
@foreach (var item in Model)
{
    <tr>
        <td>@item.OrderNumber</td>
        <td>@item.CustomerName</td>
        <td>$@item.Total</td>
    </tr>
}
</table>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

public ActionResult Index()

{

var orders = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Order, OrderDto>()

.ForMember(dest => dest.OrderNumber, opt => opt.MapFrom(src => src.OrderNo))

.ForMember(dest => dest.OrderItemsDto, opt => opt.Ignore());

var model = AutoMapper.Mapper.Map<IEnumerable<Order>, IEnumerable<OrderDto>>(orders);

return View(model);

}

//Razor View Code

<h2>Orders</h2>

<table>

<tr>

<th>Order Number</th>

<th>Total</th>

</tr>

@foreach (var item in Model)

{

<tr>

<td>@item.OrderNumber</td>

<td>@item.CustomerName</td>

<td>$@item.Total</td>

</tr>

}

</table>

With this mapping will not get the inner mapping of OrderItems since we have told Automapper to Ignore those guys don’t map the OrderItems, as it stands OrderItemsDto would be null

This would produce a view looking like

As you can see Automapper automatically has pulled out GetTotal and populated Total Property and so is Customer object with GetName method with CustomerName. By using these simple conventions it automatically does the work for you without explicitly specifying it.

In next part we will talk about Nested mapping.

Previous Post:
Part 1 Null Subsitution

.NET, Automapper

automapper, C#, object mapping

Automapper: Mapping objects Part 1 of 7 (NullSubstitution)

Taswar Bhatti March 7, 2011 2 Comments

Recently I gave a talk on Automapper in Ottawa .Net Community, so I though I would post the main ideas of the presentation here also.

The demo was based on an Order System where there were just 3 tables/classes, “Order”, “Customer” and “OrderItems”

From the diagram we can see that a Customer has a Bio and if we pull out all the customer from a repository and display it, we may have some of them whom are missing the Bio.

Here is the code of how we are mapping our domain objects to a Dto or ViewModel, we are basically just passing the data to the View to render

//customer dto
public class CustomerDto
    {
        public string Bio { get; set; }
        public string Name { get; set; }
    }

//Controller
public ActionResult Index()
        {
            var customers = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Customer, CustomerDto>();          
            var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);
                       
            return View(model);
        }

//View
<h2>Customers</h2>

@foreach (var customer in Model)
{
    <p>
    @("Name : " + customer.Name) <br /> 
    @("Bio : " + customer.Bio) <br />
    </p> 
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

//customer dto

public class CustomerDto

{

public string Bio { get; set; }

public string Name { get; set; }

}

//Controller

public ActionResult Index()

{

var customers = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Customer, CustomerDto>();

var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);

return View(model);

}

//View

<h2>Customers</h2>

@foreach (var customer in Model)

{

<p>

@("Name : " + customer.Name) <br />

@("Bio : " + customer.Bio) <br />

</p>

}

Now lets say you want to replace the Null Bio with something like “N/A”, some people may go directly to the razor view code and add that but we can do better with automapper, we can tell automapper that when there is a Null just substitute (i.e NullSubsitution) it with something else, our code would then look like

 public ActionResult Index()
        {
            var customers = _respository.GetAll();

            AutoMapper.Mapper.CreateMap<Customer, CustomerDto>()
                .ForMember(dest => dest.Bio, opt => opt.NullSubstitute("N/A"));
            var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);
                       
            return View(model);
        }

1

2

3

4

5

6

7

8

9

10

public ActionResult Index()

{

var customers = _respository.GetAll();

AutoMapper.Mapper.CreateMap<Customer, CustomerDto>()

.ForMember(dest => dest.Bio, opt => opt.NullSubstitute("N/A"));

var model = AutoMapper.Mapper.Map<IEnumerable<Customer>, IEnumerable<CustomerDto>>(customers);

return View(model);

}

In doing so we will use the same View but now we have “N/A” for “Uncle Leo” bio.

In part2 we will be talking about how to flatten objects by convention.

.NET, Automapper

automapper, C#, object mapping

Starting an Agile Team to become the A Team

Taswar Bhatti January 25, 2011 2 Comments

Here are some recommendations to any team lead or development manager to have effective agile teams.

_{Note: these are just recommendations}

Get a white board for your Kanban or Scrum task and stick iteration tasks on the board publicly not in your office or cubicle
Get every developer 2 monitors, that includes the QA since they should be part of your team. For team lead get them 3. One for monitoring the build or Nabaztag build bunny. Hold people accountable for breaking daily builds (buy donuts, pay a dollar into the pool for pizza, etc)
Every developer machine should have 16G of ram or min 8G, anything less is unacceptable.
Use a source control, bug tracker, and continuous build/integration
Get a Powerful Build machine, install TeamCity or Hudson or CruiseControl or get TFS build agent running, or use the cloud to build.
Get tools like Reflector, Resharper or CodeRush, Test Driver .Net, Code Coverage (dotCover, NCover) and “teach, guide” them how to use it effectively, shortcuts etc
Get a wiki up and running for documentation of how to’s (local build, server build, etc )
Teach the team proper unit testing, whichever framework you choose (NUnit, MbUnit, etc etc)
Teach them mocking, whichever framework you choose (Rhino Mocks, Typemock Isolator, Moq, JustMock, etc) pick one and stick to it
Teach the entire team how to debug effectively, using your IDE, teach them what pdb files are and how to remote debug if in .NET world, if you are in Java teach them how to debug a JVM, in Ruby just have them write unit test 🙂
Have the entire team know about your build and document it on a wiki, don’t just have one person who is the build master due to the bus factor (If build master gets hit by a bus tomorrow who can take over the build?)
Have only max 15 minutes daily stand-ups with format of “What I worked on yesterday, What I am working on today, and are there any impediments.”, there should be no sitting or resting or leaning on an object/wall. If there are extra things that come up, have those people with the team lead meet after the stand-up to resolve those issues.
Provide an area for collaboration, pair programming
Have a code clean up iteration for the team don’t just keep pushing features out. Let the team clean up the mess they have created.
Use a runtime analyzer to see what features users are using, tools like Gibraltar or Runtime Intelligent Service definitely helps, or if you are cheap log things into a logging database with NLog or Log4Net.
Automated! Automated! Automated!, builds, unit test, regression testing, performance testing, everyday there should be reports on what has build, passed and failed.
Provide a learning atmosphere for the team have them showcase some technology, what they have learned, or create knowledge transfer brown bag lunches.
Last but not least make it a fun learning environment for everyone involved, celebrate whenever milestones are reached, take the team out to eat to build trust. (There is something about breaking bread with someone, it builds trust.)

By the end you will have an Agile team that looks like the A Team 🙂

(hidden link in image)

Agile

agile, development, IT, manager, team, team development

Javascript Patterns: Review

Taswar Bhatti January 11, 2011 No Comments

Over the holidays I read Javascript Patterns by Stoyan Stefanov.
Its a pretty light book consisting only of 240 pages, which is light in computer reading, where majority of the books are like yellow pages phone book over 1000 pages. It was quite enjoyable to have a concise book written by Stefanov, another highly recommended book is his Object Oriented Javascript.

Anywayz here is the low down.

Chapter 1. Introduction
This chapter is more of an introduction of using firebug (console.log), jslint, object orientation and prototypes in javascript.

Chapter 2 Essentials
This chapter talks about styles and coding standards, a must read for anyone doing javascript, patterns consisting of the single var variable and minimizing global variables, commenting code, api’s etc

Chapter 3 Literals and Constructors
Its about object literal notation, constructors functions using new, array notations, json, regular expressions and build in types e.g Error consturctor.

Chapter 4 Functions
Contains an indepth use of functions in javascript as first class objects, topics covered were API Patterns (Callback, Configuration objects, returning functions and currying), Initialization patterns (immediate functions, immediate object initalization, init-time branching) and last Performance patterns (Memorization and self-defining functions)

Chapter 5 Object Creation Patterns
One learns about the namespacing pattens, declaring dependencies, private, privileged method. The module patterns, sandbox pattern and last the object constants, static methods, chaining and lastly the method() method.

Chapter 6 Code Reuse Patterns
This chapter talks about inheritance by using borrowing methods, copying properties and mixin in javascript, it also covers classical inheritance but how there are more elegant ways in javascript rather than using the classical way.

Chapter 7 Design Patterns
This chapter goes through 9 GoF patterns and how to implement them in javascript namely Singleton, Factory, Iterator, Decorator, Strategy, Facade, Mediator, Proxy and lastly Observer. The author goes about to show how one can create these patterns in javascript in various ways, it takes a different mind set then the GoF book since javascript is dynamic and functions are first class (GoF was C++ examples in static languagues), if you are a GoF head u should read this chapter.

Chapter 8 DOM and Browser Patterns
The last chapter talks about using javascript in the browser, the author uses mostly YUI, although most of the things covered are already in jquery built in, I wish he covered more on jquery but ohh well. The bonus is he talks about loading javascript how to lazy load script tags and using setTimeOut for long running operations.

Conclusion
All in all I would definitely recommend this book, its not really a beginner book but if you are doing javascript its a definite read.

As I was writing this and finishing up the blog I also saw elegant code has posted a very good review of this books on their blog.

Books, javascript

Book, Javascript, oop, patterns, review

LG Optimus One LGP500H installing usb driver (Koodoo phone Canada)

Automapper: Mapping Objects Part 7 of 7 (Startup Registration)

Automapper: Mapping objects Part 6 of 7 (CustomFormatter)

Automapper: Mapping objects Part 5 of 7 (CustomResolver)

Automapper: Mapping objects Part 4 of 7 (Projection)

Automapper: Mapping objects Part 3 of 7 (Nested Mapping)

Automapper: Mapping objects Part 2 of 7 (Flattening by Convention)

Automapper: Mapping objects Part 1 of 7 (NullSubstitution)

Starting an Agile Team to become the A Team

Here are some recommendations to any team lead or development manager to have effective agile teams.

Javascript Patterns: Review

Opinions are my own and not the views of my employer

LinkedIn

Archives