Siempre y cuando se encuentren congelados.

So having the following data table:

CreateDate                        Identifier
———————–        ————————————————–
2008-10-02 19:49:43.733 NYUB04EOB
2008-10-02 19:53:45.067 NYUB04EOB
2008-10-02 19:53:45.147 NYUB04EOB
2008-10-02 19:58:44.713 NYUB04EOB BC
2008-10-03 20:39:34.357 NYUB04EOB
2008-10-03 20:39:34.387 NYUB04EOB
2008-10-03 21:24:30.680 NYUB04EOB

we would like to group in some thing like:

CreateDate                        IdentifierCount
———————–        ———–

2008-10-02 00:00:00.000 4
2008-10-03 00:00:00.000 11
2008-10-06 00:00:00.000 11
2008-10-07 00:00:00.000 17
2008-10-08 00:00:00.000 5
2008-10-09 00:00:00.000 4
2008-10-10 00:00:00.000 7

There is actually two ways for accomplish this, the first on is assuming that you have SQL 2008 installed you could use the convert() function to do a cast to the new Date Data Type

SELECT Convert(Date,Createdate,101) as CreateDate, count(Identifier) as IdentifierCount
FROM MyTable
group by Convert(Date,Createdate,101)

The Second one is in the case that you have previous versions of SQL like 2005 or 2003, in that case the Date dataType does not exist in the short version as in 2008, so the solution is kind of tricky, ans you will have to use a DateAdd function call like follows:

SELECT top 100  dateadd(dd,0, datediff(dd,0,i.CreateDate)) as CreateDate
        ,Count(t.itypename) As Identifier       
FROM [dbo].[tritem] i (nolock) inner join
        dbo.trItemUDFDocumentUDFs u (nolock) on i.itemid = u.itemid inner join
        dbo.trItemType t (nolock) on i.itypeid = t.itypeid
WHERE t.itypename like ‘%EOB%’ and u.voided <> ‘Y’
group by dateadd(dd,0, datediff(dd,0,i.CreateDate))
order by dateadd(dd,0, datediff(dd,0,i.CreateDate))

Well, IIS administration option is a

mystery to me now, in regards of the Anonymous authentication there are a couple of good reasons for getting rid of it, and most of them have to due with Security and best practices, but there are some specific cases where you may want certain users to have access to the reports through the reports servers, here is a nice work around I’ve found on Microsoft site.

http://blogs.msdn.com/jameswu/archive/2008/07/15/anonymous-access-in-sql-rs-2008.aspx

This is a commonly seen exception thrown when deploying applications using Crystal Repots, this one specifically is in a VS 2008 application.

The issue is caused because nor crystal or visual studio include the needed assemblies on the bin directory, not even when creating a set up project for your application.

THE SOLUTION

So there are two solutions available, the first one is to get the merge modules into your set up project, that way you will ensure that the assemblies are included and registered in the installation machine

See http://msdn.microsoft.com/en-us/library/aa287928(VS.71).aspx for more refference.

How ever not all the time you are dealing with set up projects and the fast solution is to run a MSI installer, if you have visual studio 2008 installed just navigate to
C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\CrystalReports10_5 

And run the appropriate MSI.

That will make the trick.

THE PROBLEM: In design mode we have to have a reliable way for having the same signature for the service contract definition both on the client and the service as well as the data contracts.

One way to achieve this is to use the service reference functionality, which will automatically generate all a set of proxy classes for interfacing with any client we are working on it, Very useful and easy to implement, the downside of this is that we don’t have much control of what happens in the background, and if you are a WCF Rookie as I am, you will find the resulting classes extensively overwhelming. One more thing I don’t like about it is the fact that it does not give you control on the creation of the channels, which many times you will want to control.

THE GUIDELINE (Solution): Start creating a kind of three layers solution for separating the Service/Proxy/Client Functionality.

What I heavily recommend is to start by creating a proxy library class project, which will contain the set of interfaces (if more than one service contract is to be defined there) and the set of data contracts.

Then create the service and the client projects in your VS and reference the proxy project on them, this will ensure that any change you make to the service signature will be then implemented at build time on the rest of the projects

Once you have the different projects then you can go ahead and define what ever interface you want to implement for your service in an interface, on the proxy project:

namespace WCFProxy

{

[ServiceContract(SessionMode = SessionMode.Required,)]

public interface ICetralService

{

[OperationContract(IsOneWay = true)]

void UploadVersion( FileRequest request);

[OperationContract(IsOneWay = true)]

void DownloadVersion();

}

}

Also Define the Data contracts in this same project

namespace WCFProxy

{

[DataContract]

public class FileRequest

{

string _version;

List<byte[]> _fileList = new List<byte[]>();

[DataMember]

public string Version

{ get; set; }

[DataMember]

public List<byte[]> FileList

{ get; set; }

}

}

Next step is to implement the interface on the Service Project:

namespace WCFCentral

{

[ServiceBehavior(AutomaticSessionShutdown = true

, InstanceContextMode = InstanceContextMode.PerSession

, ConcurrencyMode = ConcurrencyMode.Multiple

, UseSynchronizationContext = true)]

class CentralService:WCFProxy.ICetralService

{

#region ICetralService Members

public void UploadVersion(WCFProxy.FileRequest request)

{

//WhatEver code

}

public void DownloadVersion()

{

//WhatEver code

}

#endregion

}

}

You can add any logic, or extra logic on the service, just take into account the host in which the service will be implemented, i.e. do not implement GUI interaction if it is going to be hosted in Win Service

Last but not least is to add the required logic in the client side to instantiate and host the service, this is easily accomplished by using ChannelFactory or DuplexChannelFactory, depending on the type of communication scheme you want to implement:

namespace WCFClient

{

class Client

{

public Client()

{

byte[] b = new byte[5000];//assuming the file to be sent is less that 5000 bytes

WCFProxy.FileRequest req = new WCFProxy.FileRequest();

req.Version = “1.0.1″;

b = System.IO.File.ReadAllBytes(“c:\\anyFile.txt”);

req.FileList.Add(b);

InstanceContext IC = new InstanceContext(new ClientCallBack());

DuplexChannelFactory<WCFProxy.ICetralService> f = new DuplexChannelFactory<WCFProxy.ICetralService>(IC, “CentralClient”);

Svc = f.CreateChannel();

Console.WriteLine(“about to send”);

Svc.UploadVersion(req);

Console.ReadKey();

}

private WCFProxy.ICetralService svc;

public WCFProxy.ICetralService Svc

{

get { return svc; }

set { svc = value; }

}

}

}

In this sample we assume there is an endpoint and service definition on the app.config, but this clearly and in an easy way demonstrate that you should not write huge classes or implement complex proxies to connect to any WCF service.

NICE: the important part of this sample is the separation of the contracts (Proxy) from the Service and clients, and the way we ensure that any change made to a contract definition will be distributed across the rest of the elements of a WCF platform.

Also it’s a good practice to have a good Channel handling to ensure that the channel object will open and close and also dispose correctly.

We will cover that in another blog entry.