WCF Data Services/Entity Framework : Logging client's username, Authentication, Authorization

Question

I am using Entity Framework with WCF Data Services and I have the following table in my database :

Table Contract

• Id (int)
• Name (varchar)
• byUser (varchar)
• isDeleted (bit)

Entity Framework class

• Id (int)
• Name(string)
• byUser(string)
• isDeleted(boolean)

whenever the user is inserting/updating/deleting a contract(through a client app), I need to log who did the action.

so, I created Stored procedures for insert/update/delete that will receive the username from the client when an insertion/deletion/update is performed.

the issue is that the delete operation does not send over who is performing the operation :

        var ctx = Context;
        var contractToDelete = ctx.Contracts.Where(c => c.ContractId == 1).First();
        contractToDelete.ByUser = username;
        ctx.DeleteObject(contractToDelete);
        ctx.SaveChanges();

at the server side, the byUser is always null.

Questions :

1) How do I make it so that the byUser parameter is sent to the server ?

2) Is there a better way to handle this kind of scenario ? (logging/authentication/authorization) with Entity Framework

Answer 1

It doesn't send null "always". It sends the old value always. That is some internal logic in entity framework. For each tracked object EF keeps both original and current values. When you are deleting object EF doesn't use current values - it uses original values (don't ask me why, simply this is how it works).

So you need to cheat EF:

var ctx = Context;
var contractToDelete = ctx.Contracts.Where(c => c.ContractId == 1).First();
contractToDelete.ByUser = username;
ctx.Contracts.ApplyOriginalValues(contractToDelete);
ctx.DeleteObject(contractToDelete);
ctx.SaveChanges();

Calling ApplyOriginalValues will force EF to override original values with values passed in parameter = you will override original values with current values.

In my opinion the better way is storing deleted records in separate table because it will avoid a lot of problems with passing isDeleted=false to every query where both eager and lazy loading will load deleted records as well. The only way to avoid problems with isDeleted is using conditional mapping but in such case you will not be able to load deleted records even if you want to unless you use stored procedures or direct SQL queries.