← Back to branch summary

~ubuntu-branches/ubuntu/hoary/monodevelop/hoary

« back to all changes in this revision

Viewing changes to src/Main/Base/Gui/Dialogs/ReferenceDialog/WebReference.cs

  • Committer: Bazaar Package Importer
  • Author(s): Brandon Hale
  • Date: 2004-10-07 11:51:11 UTC
  • Revision ID: james.westby@ubuntu.com-20041007115111-pxcqnwfxyq5mhcx5
Tags: 0.5.1-3
Use dh_netdeps in debian/rules and debian/control

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Main/Base/Gui/Dialogs/ReferenceDialog/WebReference.cs
 
1
// created on 10/11/2002 at 2:08 PM
 
2
 
 
3
using System;
 
4
using System.Collections;
 
5
using System.IO;
 
6
using System.Text;
 
7
using System.Runtime.InteropServices;
 
8
using System.Diagnostics;
 
9
using System.Xml;
 
10
using System.Net;
 
11
using System.Web.Services.Description;
 
12
using System.CodeDom;
 
13
using System.CodeDom.Compiler;
 
14
using System.Reflection;
 
15
 
 
16
using MonoDevelop.Internal.Project;
 
17
using MonoDevelop.Core.Services;
 
18
 
 
19
namespace MonoDevelop.Gui.Dialogs
 
20
{
 
21
        /// <summary>
 
22
        /// Summary description for WebReference.
 
23
        /// </summary>
 
24
        public class WebReference
 
25
        {       
 
26
                ///
 
27
                /// <summary>Creates a ServiceDescription object from a valid URI</summary>
 
28
                /// 
 
29
                public static ServiceDescription ReadServiceDescription(string uri) {
 
30
                        ServiceDescription desc = null;
 
31
                        
 
32
                        try {
 
33
                                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
 
34
                                WebResponse response  = request.GetResponse();
 
35
                        
 
36
                                desc = ServiceDescription.Read(response.GetResponseStream());
 
37
                                response.Close();
 
38
                                desc.RetrievalUrl = uri;
 
39
                        } catch (Exception) {                           
 
40
                                // possibly error reading WSDL?
 
41
                                return null;
 
42
                        }               
 
43
                        if(desc.Services.Count == 0)
 
44
                                return null;
 
45
                        
 
46
                        return desc;
 
47
                }
 
48
                
 
49
                ///
 
50
                /// <summary>Generates a valid directory from a URI</summary>
 
51
                /// 
 
52
                public static string GetDirectoryFromUri(string uri) {
 
53
                        // TODO: construct the namespace using th URL in the WSDL
 
54
                        string tmp = uri;
 
55
                        if(uri.IndexOf("://") > -1) {
 
56
                                tmp = uri.Substring(uri.IndexOf("://") + 3);
 
57
                        }
 
58
                        tmp = tmp.Substring(0, tmp.LastIndexOf("/"));                   
 
59
                        string[] dirs = tmp.Split(new Char[] {'/'});
 
60
                                                
 
61
                        StringBuilder savedir = new StringBuilder();
 
62
                        savedir.Append(dirs[0]);
 
63
                
 
64
                        return savedir.ToString();
 
65
                }
 
66
                
 
67
                ///
 
68
                /// <summary>Generates a valid Namespace from a URI</summary>
 
69
                /// 
 
70
                public static string GetNamespaceFromUri(string uri) {
 
71
                        // TODO: construct the namespace using th URL in the WSDL
 
72
                        string tmp = uri;
 
73
                        if(uri.IndexOf("://") > -1) {
 
74
                                tmp = uri.Substring(uri.IndexOf("://") + 3);
 
75
                        }
 
76
                        tmp = tmp.Substring(0, tmp.LastIndexOf("/"));                   
 
77
                        string[] dirs = tmp.Split(new Char[] {'/'});
 
78
                                                                                        
 
79
                        return(dirs[0]);                        
 
80
                }
 
81
                
 
82
                
 
83
                public static ProjectReference GenerateWebProxyDLL(IProject project, ServiceDescription desc) {
 
84
                        ProjectReference refInfo = null;
 
85
                        
 
86
                        string serviceName = String.Empty;
 
87
                        if(desc.Services.Count > 0) {
 
88
                                serviceName = desc.Services[0].Name;
 
89
                        } else {
 
90
                                serviceName = "UnknownService";
 
91
                        }                                                                       
 
92
                                                                
 
93
                        string nmspace = GetNamespaceFromUri(desc.RetrievalUrl);
 
94
                        
 
95
                        StringBuilder savedir = new StringBuilder();
 
96
                        savedir.Append(project.BaseDirectory);
 
97
                        savedir.Append(Path.DirectorySeparatorChar);
 
98
                        savedir.Append("WebReferences");                        
 
99
                        // second, create the path if it doesn't exist
 
100
                        DirectoryInfo di;               
 
101
                        if(!Directory.Exists(savedir.ToString()))
 
102
                        {
 
103
                                di = Directory.CreateDirectory(savedir.ToString());
 
104
                        }
 
105
                        
 
106
                        // generate the assembly
 
107
                        ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
 
108
                        importer.AddServiceDescription(desc, null, null);
 
109
                        
 
110
                        CodeNamespace codeNamespace = new CodeNamespace(nmspace);
 
111
                        CodeCompileUnit codeUnit = new CodeCompileUnit();
 
112
                        codeUnit.Namespaces.Add(codeNamespace);
 
113
                        ServiceDescriptionImportWarnings warnings = importer.Import(codeNamespace, codeUnit);
 
114
                        
 
115
                        CodeDomProvider provider = new Microsoft.CSharp.CSharpCodeProvider();                   
 
116
                        System.CodeDom.Compiler.ICodeCompiler compiler;
 
117
                        
 
118
                        
 
119
                        if(provider != null) {
 
120
                                compiler = provider.CreateCompiler();
 
121
                                CompilerParameters parms = new CompilerParameters();
 
122
                                parms.ReferencedAssemblies.Add("System.Dll");
 
123
                                parms.ReferencedAssemblies.Add("System.Xml.Dll");
 
124
                                parms.ReferencedAssemblies.Add("System.Web.Services.Dll");
 
125
                                parms.OutputAssembly = project.BaseDirectory + Path.DirectorySeparatorChar + "WebReferences" + Path.DirectorySeparatorChar + nmspace + ".Reference.Dll";
 
126
                                CompilerResults results = compiler.CompileAssemblyFromDom(parms, codeUnit);
 
127
                                Assembly assembly = results.CompiledAssembly;
 
128
                                
 
129
                                if(assembly != null) {
 
130
                                        refInfo = new ProjectReference();
 
131
                                        refInfo.ReferenceType = ReferenceType.Assembly;
 
132
                                        refInfo.Reference = parms.OutputAssembly;
 
133
                                }
 
134
                        }
 
135
                        
 
136
                        return refInfo;
 
137
                }
 
138
                
 
139
                ///
 
140
                /// <summary>Generates a Web Service proxy DLL from a URI</summary>
 
141
                /// 
 
142
                public static ProjectReference GenerateWebProxyDLL(IProject project, string url) {
 
143
                                                                        
 
144
                        ServiceDescription desc = ReadServiceDescription(url);                                          
 
145
                        return GenerateWebProxyDLL(project, desc);
 
146
                                                                        
 
147
                }
 
148
                
 
149
                public static ArrayList GenerateWebProxyCode(IProject project, ServiceDescription desc) {               
 
150
                        ArrayList fileList = null;
 
151
                        
 
152
                        string serviceName = String.Empty;
 
153
                        if(desc.Services.Count > 0) {
 
154
                                serviceName = desc.Services[0].Name;
 
155
                        } else {
 
156
                                serviceName = "UnknownService";
 
157
                        }                                                                       
 
158
                        
 
159
                        string webRefFolder = "Web References";
 
160
                        string nmspace = GetNamespaceFromUri(desc.RetrievalUrl);
 
161
                                                                                                
 
162
                        StringBuilder savedir = new StringBuilder();
 
163
                        savedir.Append(project.BaseDirectory);
 
164
                        savedir.Append(Path.DirectorySeparatorChar);
 
165
                        savedir.Append(webRefFolder);
 
166
                        savedir.Append(Path.DirectorySeparatorChar);                    
 
167
                        savedir.Append(GetDirectoryFromUri(desc.RetrievalUrl) + Path.DirectorySeparatorChar + serviceName);
 
168
                        
 
169
                        // second, create the path if it doesn't exist
 
170
                        DirectoryInfo di;               
 
171
                        if(!Directory.Exists(savedir.ToString()))
 
172
                        {
 
173
                                di = Directory.CreateDirectory(savedir.ToString());
 
174
                        }
 
175
                        
 
176
                        // generate the assembly
 
177
                        ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
 
178
                        importer.AddServiceDescription(desc, null, null);
 
179
                        
 
180
                        CodeNamespace codeNamespace = new CodeNamespace(nmspace);
 
181
                        CodeCompileUnit codeUnit = new CodeCompileUnit();
 
182
                        codeUnit.Namespaces.Add(codeNamespace);
 
183
                        ServiceDescriptionImportWarnings warnings = importer.Import(codeNamespace, codeUnit);
 
184
                        
 
185
                        CodeDomProvider provider;
 
186
                        System.CodeDom.Compiler.ICodeGenerator generator;
 
187
                        
 
188
                        String ext = String.Empty;
 
189
                        switch(project.ProjectType) {
 
190
                                case "C#":
 
191
                                        provider = new Microsoft.CSharp.CSharpCodeProvider();
 
192
                                        ext = "cs";
 
193
                                        break;
 
194
                                case "VBNET":
 
195
                                        provider = new Microsoft.VisualBasic.VBCodeProvider();                                  
 
196
                                        ext = "vb";
 
197
                                        break;
 
198
                                                        
 
199
                                default:
 
200
                                        // project type not supported error
 
201
                                        provider = null;                        
 
202
                                        break;
 
203
                        }
 
204
 
 
205
                        string filename = savedir.ToString() + Path.DirectorySeparatorChar + serviceName + "WebProxy." + ext;
 
206
                        string wsdlfilename = savedir.ToString() + Path.DirectorySeparatorChar + serviceName + ".wsdl";
 
207
                                                
 
208
                        if(provider != null) {                          
 
209
                                StreamWriter sw = new StreamWriter(filename);
 
210
 
 
211
                                generator = provider.CreateGenerator();
 
212
                                CodeGeneratorOptions options = new CodeGeneratorOptions();
 
213
                                options.BracingStyle = "C";
 
214
                                generator.GenerateCodeFromCompileUnit(codeUnit, sw, options);
 
215
                                sw.Close();
 
216
 
 
217
                                if(File.Exists(filename)) 
 
218
                                {
 
219
                                        fileList = new ArrayList();
 
220
                                        
 
221
                                        // add project files to the list
 
222
                                        ProjectFile pfile = new ProjectFile();
 
223
                                        
 
224
                                        pfile.Name = project.BaseDirectory + Path.DirectorySeparatorChar + webRefFolder;
 
225
                                        pfile.BuildAction = BuildAction.Nothing;                                        
 
226
                                        pfile.Subtype = Subtype.WebReferences;
 
227
                                        pfile.DependsOn = String.Empty;
 
228
                                        pfile.Data = String.Empty;                                                                              
 
229
                                        fileList.Add(pfile);
 
230
                                        
 
231
                                        /*
 
232
                                        pfile = new ProjectFile();
 
233
                                        pfile.Name = project.BaseDirectory + @"\Web References\" + nmspace;
 
234
                                        pfile.BuildAction = BuildAction.Nothing;
 
235
                                        pfile.Subtype = Subtype.Directory;
 
236
                                        pfile.DependsOn = project.BaseDirectory + @"\Web References\";
 
237
                                        pfile.WebReferenceUrl = String.Empty;                                                                                                                   
 
238
                                        fileList.Add(pfile);
 
239
                                        */                                      
 
240
                                        /*
 
241
                                        pfile = new ProjectFile();
 
242
                                        pfile.Name = project.BaseDirectory + @"\Web References\" + nmspace + @"\" + serviceName;
 
243
                                        pfile.BuildAction = BuildAction.Nothing;
 
244
                                        pfile.Subtype = Subtype.Directory;
 
245
                                        pfile.DependsOn = project.BaseDirectory + @"\Web References\" + nmspace + @"\";
 
246
                                        pfile.WebReferenceUrl = desc.RetrievalUrl;
 
247
                                        fileList.Add(pfile);                                                                            
 
248
                                        */
 
249
                                        // the Web Reference Proxy
 
250
                                        pfile = new ProjectFile();
 
251
                                        pfile.Name = filename;
 
252
                                        pfile.BuildAction = BuildAction.Compile;
 
253
                                        pfile.Subtype = Subtype.Code;
 
254
                                        pfile.DependsOn = project.BaseDirectory + Path.DirectorySeparatorChar + webRefFolder;
 
255
                                        pfile.Data = desc.RetrievalUrl;                                 
 
256
                                        fileList.Add(pfile);                                                                            
 
257
                                        
 
258
                                        // the WSDL File used to generate the Proxy
 
259
                                        desc.Write(wsdlfilename);
 
260
                                        pfile = new ProjectFile();
 
261
                                        pfile.Name = wsdlfilename;
 
262
                                        pfile.BuildAction = BuildAction.Nothing;
 
263
                                        pfile.Subtype = Subtype.Code;
 
264
                                        pfile.DependsOn = project.BaseDirectory + Path.DirectorySeparatorChar + webRefFolder;
 
265
                                        pfile.Data = desc.RetrievalUrl;
 
266
                                        fileList.Add(pfile);
 
267
                                }
 
268
                        }
 
269
                        
 
270
                        return fileList;
 
271
                }
 
272
                
 
273
                ///
 
274
                /// <summary>Generates a Web Service proxy class from a URI</summary>
 
275
                /// 
 
276
                public static ArrayList GenerateWebProxyCode(IProject project, string url) {
 
277
                        
 
278
                        
 
279
                        ServiceDescription desc = ReadServiceDescription(url);
 
280
                        
 
281
                        return GenerateWebProxyCode(project, desc);
 
282
                        
 
283
                        
 
284
                }
 
285
        }
 
286
}