loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

Merge branch 'FinderSystems-nancyfx-codegen'

Browse Source
This commit is contained in:
wing328 2016-06-21 23:48:58 +08:00
commit 61015488d2
35 changed files with 3577 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
README.md
View File

@ -461,6 +461,7 @@ JavaJerseyServerCodegen.java
JavaResteasyServerCodegen.java
JavascriptClientCodegen.java
NodeJSServerCodegen.java
NancyFXServerCodegen
ObjcClientCodegen.java
PerlClientCodegen.java
PhpClientCodegen.java
@ -698,6 +699,7 @@ Here are some companies/projects using Swagger Codegen in production. To add you
- [eureka](http://eure.jp/)
- [everystory.us](http://everystory.us)
- [Expected Behavior](http://www.expectedbehavior.com/)
- [Finder](http://en.finder.pl/)
- [FH Münster - University of Applied Sciences](http://www.fh-muenster.de)
- [GraphHopper](https://graphhopper.com/)
- [Gravitate Solutions](http://gravitatesolutions.com/)
@ -767,6 +769,7 @@ Swaagger Codegen core team members are contributors who have been making signfic
| Java Spring Boot | |
| Java SpringMVC | @kolyjjj (2016/05/01) |
| Java JAX-RS | |
| NancyFX | |
| NodeJS | @kolyjjj (2016/05/01) |
| PHP Lumen | @abcsum (2016/05/01) |
| PHP Silex | |

10
bin/windows/nancyfx-petstore-server.bat Normal file
View File

@ -0,0 +1,10 @@
set executable=.\modules\swagger-codegen-cli\target\swagger-codegen-cli.jar
If Not Exist %executable% (
mvn clean package
)
set JAVA_OPTS=%JAVA_OPTS% -Xmx1024M -DloggerPath=conf/log4j.properties
set ags=generate -t modules\swagger-codegen\src\main\resources\nancyfx -i modules\swagger-codegen\src\test\resources\2_0\petstore.json -l nancyfx -o samples\server\petstore\nancyfx\
java %JAVA_OPTS% -jar %executable% %ags%

13
modules/swagger-codegen/src/main/java/io/swagger/codegen/CodegenModel.java
View File

@ -5,6 +5,7 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Objects;
import io.swagger.models.ExternalDocs;
@ -29,6 +30,7 @@ public class CodegenModel {
public List<CodegenProperty> readOnlyVars = new ArrayList<CodegenProperty>(); // a list of read-only properties
public List<CodegenProperty> readWriteVars = new ArrayList<CodegenProperty>(); // a list of properties for read, write
public List<CodegenProperty> allVars;
public List<CodegenProperty> parentVars = new ArrayList<>();
public Map<String, Object> allowableValues;
// Sorted sets of required parameters.
@ -36,7 +38,7 @@ public class CodegenModel {
public Set<String> allMandatory;
public Set<String> imports = new TreeSet<String>();
public Boolean hasVars, emptyVars, hasMoreModels, hasEnums, isEnum, hasRequired, isArrayModel;
public Boolean hasVars, emptyVars, hasMoreModels, hasEnums, isEnum, hasRequired, isArrayModel, hasChildren;
public Boolean hasOnlyReadOnly = true; // true if all properties are read-only
public ExternalDocs externalDocs;
@ -122,6 +124,12 @@ public class CodegenModel {
return false;
if (externalDocs != null ? !externalDocs.equals(that.externalDocs) : that.externalDocs != null)
return false;
if (!Objects.equals(hasOnlyReadOnly, that.hasOnlyReadOnly))
return false;
if (!Objects.equals(hasChildren, that.hasChildren))
return false;
if (!Objects.equals(parentVars, that.parentVars))
return false;
return vendorExtensions != null ? vendorExtensions.equals(that.vendorExtensions) : that.vendorExtensions == null;
}
@ -158,6 +166,9 @@ public class CodegenModel {
result = 31 * result + (isEnum != null ? isEnum.hashCode() : 0);
result = 31 * result + (externalDocs != null ? externalDocs.hashCode() : 0);
result = 31 * result + (vendorExtensions != null ? vendorExtensions.hashCode() : 0);
result = 31 * result + Objects.hash(hasOnlyReadOnly);
result = 31 * result + Objects.hash(hasChildren);
result = 31 * result + Objects.hash(parentVars);
return result;
}
}

17
modules/swagger-codegen/src/main/java/io/swagger/codegen/CodegenProperty.java
View File

@ -2,8 +2,9 @@ package io.swagger.codegen;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public class CodegenProperty {
public class CodegenProperty implements Cloneable {
public String baseName, complexType, getter, setter, description, datatype, datatypeWithEnum,
name, min, max, defaultValue, defaultValueWithParam, baseType, containerType;
@ -43,6 +44,7 @@ public class CodegenProperty {
public CodegenProperty items;
public Map<String, Object> vendorExtensions;
public Boolean hasValidation; // true if pattern, maximum, etc are set (only used in the mustache template)
public Boolean isInherited;
@Override
public String toString() {
@ -105,6 +107,7 @@ public class CodegenProperty {
result = prime * result + ((isDateTime == null) ? 0 : isDateTime.hashCode());
result = prime * result + ((isMapContainer == null) ? 0 : isMapContainer.hashCode());
result = prime * result + ((isListContainer == null) ? 0 : isListContainer.hashCode());
result = prime * result + Objects.hashCode(isInherited);
return result;
}
@ -256,6 +259,18 @@ public class CodegenProperty {
if (this.isMapContainer != other.isMapContainer && (this.isMapContainer == null || !this.isMapContainer.equals(other.isMapContainer))) {
return false;
}
if (!Objects.equals(this.isInherited, other.isInherited)) {
return false;
}
return true;
}
@Override
public CodegenProperty clone() {
try {
return (CodegenProperty) super.clone();
} catch (CloneNotSupportedException e) {
throw new IllegalStateException(e);
}
}
}

404
modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/NancyFXServerCodegen.java Normal file
View File

@ -0,0 +1,404 @@
package io.swagger.codegen.languages;
import static com.google.common.base.Strings.isNullOrEmpty;
import static io.swagger.codegen.CodegenConstants.OPTIONAL_PROJECT_FILE;
import static io.swagger.codegen.CodegenConstants.OPTIONAL_PROJECT_FILE_DESC;
import static io.swagger.codegen.CodegenConstants.PACKAGE_NAME;
import static io.swagger.codegen.CodegenConstants.PACKAGE_VERSION;
import static io.swagger.codegen.CodegenConstants.RETURN_ICOLLECTION;
import static io.swagger.codegen.CodegenConstants.RETURN_ICOLLECTION_DESC;
import static io.swagger.codegen.CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG;
import static io.swagger.codegen.CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG_DESC;
import static io.swagger.codegen.CodegenConstants.SOURCE_FOLDER;
import static io.swagger.codegen.CodegenConstants.SOURCE_FOLDER_DESC;
import static io.swagger.codegen.CodegenConstants.USE_COLLECTION;
import static io.swagger.codegen.CodegenConstants.USE_COLLECTION_DESC;
import static io.swagger.codegen.CodegenConstants.USE_DATETIME_OFFSET;
import static io.swagger.codegen.CodegenConstants.USE_DATETIME_OFFSET_DESC;
import static io.swagger.codegen.CodegenType.SERVER;
import static java.util.Arrays.asList;
import static java.util.UUID.randomUUID;
import static org.apache.commons.lang3.StringUtils.capitalize;
import io.swagger.codegen.CodegenModel;
import io.swagger.codegen.CodegenOperation;
import io.swagger.codegen.CodegenProperty;
import io.swagger.codegen.CodegenType;
import io.swagger.codegen.SupportingFile;
import io.swagger.models.Swagger;
import io.swagger.models.properties.Property;
import io.swagger.models.properties.StringProperty;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Predicate;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Multimap;
public class NancyFXServerCodegen extends AbstractCSharpCodegen {
private static final Logger log = LoggerFactory.getLogger(NancyFXServerCodegen.class);
private static final String API_NAMESPACE = "Modules";
private static final String MODEL_NAMESPACE = "Models";
private static final String IMMUTABLE_OPTION = "immutable";
private static final Map<String, Predicate<Property>> propertyToSwaggerTypeMapping =
createPropertyToSwaggerTypeMapping();
private final String packageGuid = "{" + randomUUID().toString().toUpperCase() + "}";
private final Map<String, DependencyInfo> dependencies = new HashMap<>();
private final Set<String> parentModels = new HashSet<>();
private final Multimap<String, CodegenModel> childrenByParent = ArrayListMultimap.create();
private final BiMap<String, String> modelNameMapping = HashBiMap.create();
public NancyFXServerCodegen() {
outputFolder = "generated-code" + File.separator + getName();
apiTemplateFiles.put("api.mustache", ".cs");
// contextually reserved words
setReservedWordsLowerCase(
asList("var", "async", "await", "dynamic", "yield")
);
cliOptions.clear();
// CLI options
addOption(PACKAGE_NAME, "C# package name (convention: Title.Case).", packageName);
addOption(PACKAGE_VERSION, "C# package version.", packageVersion);
addOption(SOURCE_FOLDER, SOURCE_FOLDER_DESC, sourceFolder);
// CLI Switches
addSwitch(SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_BY_REQUIRED_FLAG_DESC, sortParamsByRequiredFlag);
addSwitch(OPTIONAL_PROJECT_FILE, OPTIONAL_PROJECT_FILE_DESC, optionalProjectFileFlag);
addSwitch(USE_DATETIME_OFFSET, USE_DATETIME_OFFSET_DESC, useDateTimeOffsetFlag);
addSwitch(USE_COLLECTION, USE_COLLECTION_DESC, useCollection);
addSwitch(RETURN_ICOLLECTION, RETURN_ICOLLECTION_DESC, returnICollection);
addSwitch(IMMUTABLE_OPTION, "Enabled by default. If disabled generates model classes with setters", true);
typeMapping.putAll(nodaTimeTypesMappings());
languageSpecificPrimitives.addAll(nodaTimePrimitiveTypes());
importMapping.clear();
}
@Override
public CodegenType getTag() {
return SERVER;
}
@Override
public String getName() {
return "nancyfx";
}
@Override
public String getHelp() {
return "Generates a NancyFX Web API server.";
}
@Override
public void processOpts() {
super.processOpts();
apiPackage = isNullOrEmpty(packageName) ? API_NAMESPACE : packageName + "." + API_NAMESPACE;
modelPackage = isNullOrEmpty(packageName) ? MODEL_NAMESPACE : packageName + "." + MODEL_NAMESPACE;
supportingFiles.add(new SupportingFile("parameters.mustache", sourceFile("Utils"), "Parameters.cs"));
supportingFiles.add(new SupportingFile("packages.config.mustache", sourceFolder(), "packages.config"));
supportingFiles.add(new SupportingFile("nuspec.mustache", sourceFolder(), packageName + ".nuspec"));
if (optionalProjectFileFlag) {
supportingFiles.add(new SupportingFile("Solution.mustache", "", packageName + ".sln"));
supportingFiles.add(new SupportingFile("Project.mustache", sourceFolder(), packageName + ".csproj"));
}
additionalProperties.put("packageGuid", packageGuid);
setupModelTemplate();
processImportedMappings();
appendDependencies();
}
private void setupModelTemplate() {
final Object immutableOption = additionalProperties.get(IMMUTABLE_OPTION);
if (immutableOption != null && "false".equalsIgnoreCase(immutableOption.toString())) {
log.info("Using mutable model template");
modelTemplateFiles.put("modelMutable.mustache", ".cs");
} else {
log.info("Using immutable model template");
modelTemplateFiles.put("model.mustache", ".cs");
}
}
private void processImportedMappings() {
for (final Entry<String, String> entry : ImmutableSet.copyOf(importMapping.entrySet())) {
final String model = entry.getKey();
final String[] namespaceInfo = entry.getValue().split("\\s");
final String[] namespace = (namespaceInfo.length > 0 ? namespaceInfo[0].trim() : "").split(":");
final String namespaceName = namespace.length > 0 ? namespace[0].trim() : null;
final String modelClass = namespace.length > 1 ? namespace[1].trim() : null;
final String assembly = namespaceInfo.length > 1 ? namespaceInfo[1].trim() : null;
final String assemblyVersion = namespaceInfo.length > 2 ? namespaceInfo[2].trim() : null;
final String assemblyFramework = namespaceInfo.length > 3 ? namespaceInfo[3].trim() : "net45";
if (isNullOrEmpty(model) || isNullOrEmpty(namespaceName)) {
log.warn(String.format("Could not import: '%s' - invalid namespace: '%s'", model, entry.getValue()));
importMapping.remove(model);
} else {
log.info(String.format("Importing: '%s' from '%s' namespace.", model, namespaceName));
importMapping.put(model, namespaceName);
}
if (!isNullOrEmpty(modelClass)) {
log.info(String.format("Mapping: '%s' class to '%s'", model, modelClass));
modelNameMapping.put(model, modelClass);
}
if (assembly != null && assemblyVersion != null) {
log.info(String.format("Adding dependency: '%s', version: '%s', framework: '%s'",
assembly, assemblyVersion, assemblyVersion));
dependencies.put(assembly, new DependencyInfo(assemblyVersion, assemblyFramework));
}
}
}
private void appendDependencies() {
final List<Map<String, String>> listOfDependencies = new ArrayList<>();
for (final Entry<String, DependencyInfo> dependency : dependencies.entrySet()) {
final Map<String, String> dependencyInfo = new HashMap<>();
dependencyInfo.put("dependency", dependency.getKey());
dependencyInfo.put("dependencyVersion", dependency.getValue().version);
dependencyInfo.put("dependencyFramework", dependency.getValue().framework);
listOfDependencies.add(dependencyInfo);
}
additionalProperties.put("dependencies", listOfDependencies);
}
private String sourceFolder() {
return "src" + File.separator + packageName;
}
private String sourceFile(final String fileName) {
return sourceFolder() + File.separator + fileName;
}
@Override
public String apiFileFolder() {
return outputFolder + File.separator + sourceFolder() + File.separator + API_NAMESPACE;
}
@Override
public String modelFileFolder() {
return outputFolder + File.separator + sourceFolder() + File.separator + MODEL_NAMESPACE;
}
@Override
protected void processOperation(final CodegenOperation operation) {
super.processOperation(operation);
if (!isNullOrEmpty(operation.path) && operation.path.contains("?")) {
operation.path = operation.path.replace("?", "/");
}
if (!isNullOrEmpty(operation.httpMethod)) {
operation.httpMethod = capitalize(operation.httpMethod.toLowerCase());
}
}
@Override
public Map<String, Object> postProcessAllModels(final Map<String, Object> models) {
final Map<String, Object> processed = super.postProcessAllModels(models);
postProcessParentModels(models);
return processed;
}
private void postProcessParentModels(final Map<String, Object> models) {
log.info("Processing parents: " + parentModels);
for (final String parent : parentModels) {
final CodegenModel parentModel = modelByName(parent, models);
parentModel.hasChildren = true;
final Collection<CodegenModel> childrenModels = childrenByParent.get(parent);
for (final CodegenModel child : childrenModels) {
processParentPropertiesInChildModel(parentModel, child);
}
}
}
private CodegenModel modelByName(final String name, final Map<String, Object> models) {
final Object data = models.get(name);
if (data instanceof Map) {
final Map<?, ?> dataMap = (Map<?, ?>) data;
final Object dataModels = dataMap.get("models");
if (dataModels instanceof List) {
final List<?> dataModelsList = (List<?>) dataModels;
for (final Object entry : dataModelsList) {
if (entry instanceof Map) {
final Map<?, ?> entryMap = (Map<?, ?>) entry;
final Object model = entryMap.get("model");
if (model instanceof CodegenModel) {
return (CodegenModel) model;
}
}
}
}
}
return null;
}
private void processParentPropertiesInChildModel(final CodegenModel parent, final CodegenModel child) {
final Map<String, CodegenProperty> childPropertiesByName = new HashMap<>(child.vars.size());
for (final CodegenProperty property : child.vars) {
childPropertiesByName.put(property.name, property);
}
CodegenProperty previousParentVar = null;
for (final CodegenProperty property : parent.vars) {
final CodegenProperty duplicatedByParent = childPropertiesByName.get(property.name);
if (duplicatedByParent != null) {
log.info(String.format("Property: '%s' in '%s' model is inherited from '%s'" ,
property.name, child.classname, parent.classname));
duplicatedByParent.isInherited = true;
final CodegenProperty parentVar = duplicatedByParent.clone();
parentVar.hasMore = false;
child.parentVars.add(parentVar);
if (previousParentVar != null) {
previousParentVar.hasMore = true;
}
previousParentVar = parentVar;
}
}
}
@Override
public void postProcessModelProperty(final CodegenModel model, final CodegenProperty property) {
super.postProcessModelProperty(model, property);
if (!isNullOrEmpty(model.parent)) {
parentModels.add(model.parent);
if (!childrenByParent.containsEntry(model.parent, model)) {
childrenByParent.put(model.parent, model);
}
}
}
@Override
public String toEnumVarName(final String name, final String datatype) {
final String enumName = camelize(
sanitizeName(name)
.replaceFirst("^_", "")
.replaceFirst("_$", "")
.replaceAll("-", "_"));
final String result;
if (enumName.matches("\\d.*")) {
result = "_" + enumName;
} else {
result = enumName;
}
log.info(String.format("toEnumVarName('%s', %s) = '%s'", name, datatype, enumName));
return result;
}
@Override
public String toApiName(final String name) {
final String apiName;
if (isNullOrEmpty(name)) {
apiName = "Default";
} else {
apiName = capitalize(name);
}
log.info(String.format("toApiName('%s') = '%s'", name, apiName));
return apiName;
}
@Override
public String toApiFilename(final String name) {
return super.toApiFilename(name) + "Module";
}
@Override
public String toModelImport(final String name) {
final String result;
if (modelNameMapping.containsValue(name)) {
final String modelName = modelNameMapping.inverse().get(name);
result = importMapping.containsKey(modelName) ?
importMapping.get(modelName) : super.toModelImport(name);
} else if (importMapping.containsKey(name)) {
result = importMapping.get(name);
} else {
result = null;
}
log.info(String.format("toModelImport('%s') = '%s'", name, result));
return result;
}
@Override
public String toModelName(final String name) {
final String modelName = super.toModelName(name);
final String mappedModelName = modelNameMapping.get(modelName);
return isNullOrEmpty(mappedModelName) ? modelName: mappedModelName;
}
@Override
public void preprocessSwagger(final Swagger swagger) {
additionalProperties.put("packageContext", sanitizeName(swagger.getBasePath()));
additionalProperties.put("baseContext", swagger.getBasePath());
}
@Override
public String toEnumName(final CodegenProperty property) {
return sanitizeName(camelize(property.name)) + "Enum";
}
@Override
public String getSwaggerType(final Property property) {
for (Entry<String, Predicate<Property>> entry : propertyToSwaggerTypeMapping.entrySet()) {
if (entry.getValue().apply(property)) {
return entry.getKey();
}
}
return super.getSwaggerType(property);
}
private static Map<String, Predicate<Property>> createPropertyToSwaggerTypeMapping() {
final ImmutableMap.Builder<String, Predicate<Property>> mapping = ImmutableMap.builder();
mapping.put("time", timeProperty());
return mapping.build();
}
private static Predicate<Property> timeProperty() {
return new Predicate<Property>() {
@Override
public boolean apply(Property property) {
return property instanceof StringProperty && "time".equalsIgnoreCase(property.getFormat());
}
};
}
private static Map<String, String> nodaTimeTypesMappings() {
return ImmutableMap.of(
"time", "LocalTime?",
"date", "ZonedDateTime?",
"datetime", "ZonedDateTime?");
}
private static Set<String> nodaTimePrimitiveTypes() {
return ImmutableSet.of("LocalTime?", "ZonedDateTime?");
}
private class DependencyInfo {
private final String version;
private final String framework;
private DependencyInfo(final String version, final String framework) {
this.version = version;
this.framework = framework;
}
}
}

3
modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig
View File

@ -17,6 +17,7 @@ io.swagger.codegen.languages.JavascriptClientCodegen
io.swagger.codegen.languages.JavascriptClosureAngularClientCodegen
io.swagger.codegen.languages.JavaJerseyServerCodegen
io.swagger.codegen.languages.JMeterCodegen
io.swagger.codegen.languages.NancyFXServerCodegen
io.swagger.codegen.languages.NodeJSServerCodegen
io.swagger.codegen.languages.ObjcClientCodegen
io.swagger.codegen.languages.PerlClientCodegen
@ -46,4 +47,4 @@ io.swagger.codegen.languages.CsharpDotNet2ClientCodegen
io.swagger.codegen.languages.ClojureClientCodegen
io.swagger.codegen.languages.HaskellServantCodegen
io.swagger.codegen.languages.LumenServerCodegen
io.swagger.codegen.languages.GoServerCodegen
io.swagger.codegen.languages.GoServerCodegen

80
modules/swagger-codegen/src/main/resources/nancyfx/Project.mustache Normal file
View File

@ -0,0 +1,80 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{{packageGuid}}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>{{packageName}}.{{packageContext}}</RootNamespace>
<AssemblyName>{{packageTitle}}</AssemblyName>
{{^supportsUWP}}
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
{{/supportsUWP}}
{{#supportsUWP}}
<TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
<TargetPlatformVersion>10.0.10240.0</TargetPlatformVersion>
<TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
<MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
{{/supportsUWP}}
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Debug\{{packageName}}.XML</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Release\{{packageName}}.XML</DocumentationFile>
</PropertyGroup>
<ItemGroup>
<Reference Include="Nancy, Version=1.4.1.0, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\Nancy.1.4.1\lib\net40\Nancy.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="NodaTime, Version=1.3.0.0, Culture=neutral, PublicKeyToken=4226afe0d9b296d1, processorArchitecture=MSIL">
<HintPath>..\..\packages\NodaTime.1.3.1\lib\net35-Client\NodaTime.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="Sharpility, Version=1.2.2.0, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\Sharpility.1.2.2\lib\net45\Sharpility.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="System.Collections.Immutable, Version=1.1.37.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\..\packages\System.Collections.Immutable.1.1.37\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
<Private>True</Private>
</Reference>{{#dependencies}}
<Reference Include="{{dependency}}, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\{{dependency}}.{{dependencyVersion}}\lib\{{dependencyFramework}}\{{dependency}}.dll</HintPath>
<Private>True</Private>
</Reference>
{{/dependencies}}
<Reference Include="System"/>
<Reference Include="System.Core"/>
<Reference Include="System.Xml.Linq"/>
<Reference Include="System.Data.DataSetExtensions"/>
<Reference Include="Microsoft.CSharp"/>
<Reference Include="System.Data"/>
<Reference Include="System.Runtime.Serialization"/>
<Reference Include="System.Xml"/>
</ItemGroup>
<ItemGroup>
<Compile Include="**\*.cs" Exclude="obj\**"/>
</ItemGroup>
<ItemGroup>
<Content Include="packages.config"/>
</ItemGroup>
<Import Project="$(MsBuildToolsPath)\Microsoft.CSharp.targets"/>
</Project>

25
modules/swagger-codegen/src/main/resources/nancyfx/Solution.mustache Normal file
View File

@ -0,0 +1,25 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2012
VisualStudioVersion = 12.0.0.0
MinimumVisualStudioVersion = 10.0.0.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "{{packageName}}", "src\{{packageName}}\{{packageName}}.csproj", "{{packageGuid}}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{{packageGuid}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{{packageGuid}}.Debug|Any CPU.Build.0 = Debug|Any CPU
{{packageGuid}}.Release|Any CPU.ActiveCfg = Release|Any CPU
{{packageGuid}}.Release|Any CPU.Build.0 = Release|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Debug|Any CPU.Build.0 = Debug|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Release|Any CPU.ActiveCfg = Release|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

74
modules/swagger-codegen/src/main/resources/nancyfx/api.mustache Normal file
View File

@ -0,0 +1,74 @@
using System;
using Nancy;
using Nancy.ModelBinding;
using System.Collections.Generic;
using Sharpility.Base;
using {{packageName}}.{{packageContext}}.Models;
using {{packageName}}.{{packageContext}}.Utils;
using NodaTime;
{{#imports}}using {{import}};
{{/imports}}
namespace {{packageName}}.{{packageContext}}.Modules
{ {{#operations}}{{#operation}}{{#allParams}}{{#isEnum}}
{{>innerApiEnum}}{{/isEnum}}{{/allParams}}{{/operation}}
/// <summary>
/// Module processing requests of {{classname}} domain.
/// </summary>
public sealed class {{classname}}Module : NancyModule
{
/// <summary>
/// Sets up HTTP methods mappings.
/// </summary>
/// <param name="service">Service handling requests</param>
public {{classname}}Module({{classname}}Service service) : base("{{baseContext}}")
{ {{#operation}}
{{httpMethod}}["{{path}}"] = parameters =>
{
{{#allParams}}{{#isBodyParam}}var {{paramName}} = this.Bind<{{&dataType}}>();{{/isBodyParam}}{{^isBodyParam}}{{#isEnum}}var {{paramName}} = Parameters.ValueOf<{{>innerApiEnumName}}?>({{>innerParameterValueOfArgs}});{{/isEnum}}{{^isEnum}}var {{paramName}} = Parameters.ValueOf<{{&dataType}}>({{>innerParameterValueOfArgs}});{{/isEnum}}{{#hasMore}}
{{/hasMore}}{{/isBodyParam}}{{/allParams}}{{#allParams}}{{#required}}
Preconditions.IsNotNull({{paramName}}, "Required parameter: '{{paramName}}' is missing at '{{operationId}}'");
{{/required}}{{/allParams}}
{{#returnType}}return {{/returnType}}service.{{operationId}}(Context{{#allParams.0}}, {{/allParams.0}}{{#allParams}}{{paramName}}{{#hasMore}}, {{/hasMore}}{{/allParams}});{{^returnType}}
return new Response { ContentType = "{{produces.0.mediaType}}"};{{/returnType}}
};
{{/operation}}
}
}
/// <summary>
/// Service handling {{classname}} requests.
/// </summary>
public interface {{classname}}Service
{
{{#operation}}/// <summary>
/// {{notes}}
/// </summary>
/// <param name="context">Context of request</param>
{{#allParams}}/// <param name="{{paramName}}">{{description}}{{^required}} (optional{{#defaultValue}}, default to {{.}}{{/defaultValue}}){{/required}}</param>
{{/allParams}}/// <returns>{{#returnType}}{{returnType}}{{/returnType}}</returns>
{{#returnType}}{{&returnType}}{{/returnType}}{{^returnType}}void{{/returnType}} {{operationId}}(NancyContext context{{#allParams.0}}, {{/allParams.0}}{{>paramsList}});{{#hasMore}}
{{/hasMore}}{{/operation}}
}
/// <summary>
/// Abstraction of {{classname}}Service.
/// </summary>
public abstract class Abstract{{classname}}Service: {{classname}}Service
{
{{#operation}}public virtual {{#returnType}}{{&returnType}}{{/returnType}}{{^returnType}}void{{/returnType}} {{operationId}}(NancyContext context{{#allParams.0}}, {{/allParams.0}}{{>paramsList}})
{
{{#returnType}}return {{/returnType}}{{operationId}}({{#allParams}}{{paramName}}{{#hasMore}}, {{/hasMore}}{{/allParams}});
}{{#hasMore}}
{{/hasMore}}{{/operation}}
{{#operation}}protected abstract {{#returnType}}{{&returnType}}{{/returnType}}{{^returnType}}void{{/returnType}} {{operationId}}({{>paramsList}});{{#hasMore}}
{{/hasMore}}{{/operation}}
}
{{/operations}}
}

4
modules/swagger-codegen/src/main/resources/nancyfx/innerApiEnum.mustache Normal file
View File

@ -0,0 +1,4 @@
/// <summary>
/// {{#description}}{{.}}{{/description}}{{^description}}{{classname}}{{/description}}
/// </summary>
public enum {{>innerApiEnumName}} { {{#allowableValues}}{{#values}}{{&.}}{{^-last}}, {{/-last}}{{/values}}{{/allowableValues}} };

1
modules/swagger-codegen/src/main/resources/nancyfx/innerApiEnumName.mustache Normal file
View File

@ -0,0 +1 @@
{{#datatypeWithEnum}}{{operationId}}{{.}}{{/datatypeWithEnum}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}

1
modules/swagger-codegen/src/main/resources/nancyfx/innerModelEnum.mustache Normal file
View File

@ -0,0 +1 @@
public enum {{#datatypeWithEnum}}{{.}}{{/datatypeWithEnum}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}} { {{#allowableValues}}{{#enumVars}}{{{name}}}{{^-last}}, {{/-last}}{{/enumVars}}{{/allowableValues}} };

1
modules/swagger-codegen/src/main/resources/nancyfx/innerParameterType.mustache Normal file
View File

@ -0,0 +1 @@
{{#isQueryParam}}ParameterType.Query{{/isQueryParam}}{{#isPathParam}}ParameterType.Path{{/isPathParam}}{{#isHeaderParam}}ParameterType.Header{{/isHeaderParam}}{{^isQueryParam}}{{^isPathParam}}{{^isHeaderParam}}ParameterType.Undefined{{/isHeaderParam}}{{/isPathParam}}{{/isQueryParam}}

1
modules/swagger-codegen/src/main/resources/nancyfx/innerParameterValueOfArgs.mustache Normal file
View File

@ -0,0 +1 @@
parameters, Context.Request, "{{paramName}}", {{>innerParameterType}}

172
modules/swagger-codegen/src/main/resources/nancyfx/model.mustache Normal file
View File

@ -0,0 +1,172 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
{{#imports}}using {{import}};
{{/imports}}
{{#models}}
{{#model}}
namespace {{packageName}}.{{packageContext}}.Models
{
/// <summary>
/// {{#description}}{{.}}{{/description}}{{^description}}{{classname}}{{/description}}
/// </summary>
public {{^hasChildren}}sealed {{/hasChildren}}class {{classname}}: {{#parent}}{{{parent}}}, {{/parent}} IEquatable<{{classname}}>
{ {{#vars}}{{^isInherited}}
/// <summary>
/// {{^description}}{{{name}}}{{/description}}{{#description}}{{description}}{{/description}}
/// </summary>
public {{>nullableDataType}} {{name}} { get; private set; }
{{/isInherited}}{{/vars}}
/// <summary>
/// Empty constructor required by some serializers.
/// Use {{classname}}.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public {{classname}}(){{#parent}} : base({{/parent}}{{#parentVars}}null{{#hasMore}}, {{/hasMore}}{{/parentVars}}{{#parent}}){{/parent}}
{
}
{{#hasChildren}}protected{{/hasChildren}}{{^hasChildren}}private{{/hasChildren}} {{classname}}({{#vars}}{{>nullableDataType}} {{name}}{{#hasMore}}, {{/hasMore}}{{/vars}}){{#parent}} : base({{#parentVars}}{{name}}{{#hasMore}}, {{/hasMore}}{{/parentVars}}){{/parent}}
{
{{#vars}}{{^isInherited}}
this.{{name}} = {{name}};
{{/isInherited}}{{/vars}}
}
/// <summary>
/// Returns builder of {{classname}}.
/// </summary>
/// <returns>{{classname}}Builder</returns>
public static {{#parent}}new {{/parent}}{{classname}}Builder Builder()
{
return new {{classname}}Builder();
}
/// <summary>
/// Returns {{classname}}Builder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>{{classname}}Builder</returns>
public {{#parent}}new {{/parent}}{{classname}}Builder With()
{
return Builder()
{{#vars}}
.{{name}}({{name}}){{#hasMore}}
{{/hasMore}}{{/vars}};
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals({{classname}} other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for ({{classname}}.
/// </summary>
/// <param name="left">Compared ({{classname}}</param>
/// <param name="right">Compared ({{classname}}</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == ({{classname}} left, {{classname}} right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for ({{classname}}.
/// </summary>
/// <param name="left">Compared ({{classname}}</param>
/// <param name="right">Compared ({{classname}}</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != ({{classname}} left, {{classname}} right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of {{classname}}.
/// </summary>
public sealed class {{classname}}Builder
{
{{#vars}}
private {{>nullableDataType}} _{{name}};
{{/vars}}
internal {{classname}}Builder()
{
SetupDefaults();
}
private void SetupDefaults()
{
{{#vars}}
{{^required}}
{{#defaultValue}}
_{{name}} = {{{defaultValue}}};
{{/defaultValue}}
{{/required}}
{{/vars}}
}
{{#vars}}
/// <summary>
/// Sets value for {{classname}}.{{{name}}} property.
/// </summary>
/// <param name="value">{{^description}}{{{name}}}{{/description}}{{#description}}{{description}}{{/description}}</param>
public {{classname}}Builder {{name}}({{>nullableDataType}} value)
{
_{{name}} = value;
return this;
}
{{/vars}}
/// <summary>
/// Builds instance of {{classname}}.
/// </summary>
/// <returns>{{classname}}</returns>
public {{classname}} Build()
{
Validate();
return new {{classname}}(
{{#vars}}
{{name}}: _{{name}}{{#hasMore}},{{/hasMore}}
{{/vars}}
);
}
private void Validate()
{ {{#vars}}{{#required}}
if (_{{name}} == null)
{
throw new ArgumentException("{{name}} is a required property for {{classname}} and cannot be null");
} {{/required}}{{/vars}}
}
}
{{#vars}}{{#isEnum}}{{^parent}}
{{>innerModelEnum}}{{/parent}}{{/isEnum}}{{#items.isEnum}}
{{#items}}{{>innerModelEnum}}{{/items}}{{/items.isEnum}}{{/vars}}
}
{{/model}}
{{/models}}
}

72
modules/swagger-codegen/src/main/resources/nancyfx/modelMutable.mustache Normal file
View File

@ -0,0 +1,72 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
{{#imports}}using {{import}};
{{/imports}}
{{#models}}
{{#model}}
namespace {{packageName}}.{{packageContext}}.Models
{ {{#vars}}{{#isEnum}}{{^parent}}
{{>innerModelEnum}}{{/parent}}{{/isEnum}}{{#items.isEnum}}
{{#items}}{{>innerModelEnum}}{{/items}}{{/items.isEnum}}{{/vars}}
/// <summary>
/// {{#description}}{{.}}{{/description}}{{^description}}{{classname}}{{/description}}
/// </summary>
public {{^hasChildren}}sealed {{/hasChildren}}class {{classname}}: {{#parent}}{{{parent}}}, {{/parent}} IEquatable<{{classname}}>
{ {{#vars}}{{^isInherited}}
/// <summary>
/// {{^description}}{{{name}}}{{/description}}{{#description}}{{description}}{{/description}}
/// </summary>
public {{>nullableDataType}} {{name}} { get; set; }
{{/isInherited}}{{/vars}}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals({{classname}} other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for ({{classname}}.
/// </summary>
/// <param name="left">Compared ({{classname}}</param>
/// <param name="right">Compared ({{classname}}</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == ({{classname}} left, {{classname}} right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for ({{classname}}.
/// </summary>
/// <param name="left">Compared ({{classname}}</param>
/// <param name="right">Compared ({{classname}}</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != ({{classname}} left, {{classname}} right)
{
return !Equals(left, right);
}
}
{{/model}}
{{/models}}
}

1
modules/swagger-codegen/src/main/resources/nancyfx/nullableDataType.mustache Normal file
View File

@ -0,0 +1 @@
{{&datatypeWithEnum}}{{#isEnum}}?{{/isEnum}}

14
modules/swagger-codegen/src/main/resources/nancyfx/nuspec.mustache Normal file
View File

@ -0,0 +1,14 @@
<?xml version="1.0"?>
<package>
<metadata>
<id>{{packageName}}</id>
<title>{{packageName}}</title>
<version>{{{version}}}</version>
<authors>swagger-codegen</authors>
<owners>swagger-codegen</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>NancyFx {{packageName}} API</description>{{#termsOfService}}
<copyright>{{termsOfService}}</copyright>{{/termsOfService}}{{#licenseUrl}}
<licenseUrl>{{licenseUrl}}</licenseUrl>{{/licenseUrl}}
</metadata>
</package>

10
modules/swagger-codegen/src/main/resources/nancyfx/packages.config.mustache Normal file
View File

@ -0,0 +1,10 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Nancy" version="1.4.1" targetFramework="net45" />
<package id="NodaTime" version="1.3.1" targetFramework="net45" />
<package id="Sharpility" version="1.2.2" targetFramework="net45" />
<package id="System.Collections.Immutable" version="1.1.37" targetFramework="net45" />
{{#dependencies}}
<package id="{{dependency}}" version="{{dependencyVersion}}" targetFramework="{{dependencyFramework}}" />
{{/dependencies}}
</packages>

414
modules/swagger-codegen/src/main/resources/nancyfx/parameters.mustache Normal file
View File

@ -0,0 +1,414 @@
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Nancy;
using NodaTime;
using NodaTime.Text;
using Sharpility.Base;
using Sharpility.Extensions;
using Sharpility.Util;
namespace {{packageName}}.{{packageContext}}.Utils
{
internal static class Parameters
{
private static readonly IDictionary<Type, Func<Parameter, object>> Parsers = CreateParsers();
internal static TValue ValueOf<TValue>(dynamic parameters, Request request, string name, ParameterType parameterType)
{
var valueType = typeof(TValue);
var valueUnderlyingType = Nullable.GetUnderlyingType(valueType);
var isNullable = default(TValue) == null;
string value = RawValueOf(parameters, request, name, parameterType);
Preconditions.Evaluate(!string.IsNullOrEmpty(value) || isNullable, string.Format("Required parameter: '{0}' is missing", name));
if (value == null && isNullable)
{
return default(TValue);
}
if (valueType.IsEnum || (valueUnderlyingType != null && valueUnderlyingType.IsEnum))
{
return EnumValueOf<TValue>(name, value);
}
return ValueOf<TValue>(parameters, name, value, valueType, request, parameterType);
}
private static string RawValueOf(dynamic parameters, Request request, string name, ParameterType parameterType)
{
try
{
switch (parameterType)
{
case ParameterType.Query:
string querValue = request.Query[name];
return querValue;
case ParameterType.Path:
string pathValue = parameters[name];
return pathValue;
case ParameterType.Header:
var headerValue = request.Headers[name];
return headerValue != null ? string.Join(",", headerValue) : null;
}
}
catch (Exception e)
{
throw new InvalidOperationException(string.Format("Could not obtain value of '{0}' parameter", name), e);
}
throw new InvalidOperationException(string.Format("Parameter with type: {0} is not supported", parameterType));
}
private static TValue EnumValueOf<TValue>(string name, string value)
{
var valueType = typeof(TValue);
var enumType = valueType.IsEnum ? valueType : Nullable.GetUnderlyingType(valueType);
Preconditions.IsNotNull(enumType, () => new InvalidOperationException(
string.Format("Could not parse parameter: '{0}' to enum. Type {1} is not enum", name, valueType)));
var values = Enum.GetValues(enumType);
foreach (var entry in values)
{
if (entry.ToString().EqualsIgnoreCases(value)
|| ((int)entry).ToString().EqualsIgnoreCases(value))
{
return (TValue)entry;
}
}
throw new ArgumentException(string.Format("Parameter: '{0}' value: '{1}' is not supported. Expected one of: {2}",
name, value, Strings.ToString(values)));
}
private static TValue ValueOf<TValue>(dynamic parameters, string name, string value, Type valueType, Request request, ParameterType parameterType)
{
var parser = Parsers.GetIfPresent(valueType);
if (parser != null)
{
return ParseValueUsing<TValue>(name, value, valueType, parser);
}
if (parameterType == ParameterType.Path)
{
return DynamicValueOf<TValue>(parameters, name);
}
if (parameterType == ParameterType.Query)
{
return DynamicValueOf<TValue>(request.Query, name);
}
throw new InvalidOperationException(string.Format("Could not get value for {0} with type {1}", name, valueType));
}
private static TValue ParseValueUsing<TValue>(string name, string value, Type valueType, Func<Parameter, object> parser)
{
var result = parser(Parameter.Of(name, value));
try
{
return (TValue)result;
}
catch (InvalidCastException)
{
throw new InvalidOperationException(
string.Format("Could not parse parameter: '{0}' with value: '{1}'. " +
"Received: '{2}', expected: '{3}'.",
name, value, result.GetType(), valueType));
}
}
private static TValue DynamicValueOf<TValue>(dynamic parameters, string name)
{
string value = parameters[name];
try
{
TValue result = parameters[name];
return result;
}
catch (InvalidCastException)
{
throw new InvalidOperationException(Strings.Format("Parameter: '{0}' value: '{1}' could not be parsed. " +
"Expected type: '{2}' is not supported",
name, value, typeof(TValue)));
}
catch (Exception e)
{
throw new InvalidOperationException(string.Format("Could not get '{0}' value of '{1}' type dynamicly",
name, typeof(TValue)), e);
}
}
private static IDictionary<Type, Func<Parameter, object>> CreateParsers()
{
var parsers = ImmutableDictionary.CreateBuilder<Type, Func<Parameter, object>>();
parsers.Put(typeof(string), value => value);
parsers.Put(typeof(bool), SafeParse(bool.Parse));
parsers.Put(typeof(bool?), SafeParse(bool.Parse));
parsers.Put(typeof(byte), SafeParse(byte.Parse));
parsers.Put(typeof(sbyte?), SafeParse(sbyte.Parse));
parsers.Put(typeof(short), SafeParse(short.Parse));
parsers.Put(typeof(short?), SafeParse(short.Parse));
parsers.Put(typeof(ushort), SafeParse(ushort.Parse));
parsers.Put(typeof(ushort?), SafeParse(ushort.Parse));
parsers.Put(typeof(int), SafeParse(int.Parse));
parsers.Put(typeof(int?), SafeParse(int.Parse));
parsers.Put(typeof(uint), SafeParse(uint.Parse));
parsers.Put(typeof(uint?), SafeParse(uint.Parse));
parsers.Put(typeof(long), SafeParse(long.Parse));
parsers.Put(typeof(long?), SafeParse(long.Parse));
parsers.Put(typeof(ulong), SafeParse(ulong.Parse));
parsers.Put(typeof(ulong?), SafeParse(ulong.Parse));
parsers.Put(typeof(float), SafeParse(float.Parse));
parsers.Put(typeof(float?), SafeParse(float.Parse));
parsers.Put(typeof(double), SafeParse(double.Parse));
parsers.Put(typeof(double?), SafeParse(double.Parse));
parsers.Put(typeof(decimal), SafeParse(decimal.Parse));
parsers.Put(typeof(decimal?), SafeParse(decimal.Parse));
parsers.Put(typeof(DateTime), SafeParse(DateTime.Parse));
parsers.Put(typeof(DateTime?), SafeParse(DateTime.Parse));
parsers.Put(typeof(TimeSpan), SafeParse(TimeSpan.Parse));
parsers.Put(typeof(TimeSpan?), SafeParse(TimeSpan.Parse));
parsers.Put(typeof(ZonedDateTime), SafeParse(ParseZonedDateTime));
parsers.Put(typeof(ZonedDateTime?), SafeParse(ParseZonedDateTime));
parsers.Put(typeof(LocalTime), SafeParse(ParseLocalTime));
parsers.Put(typeof(LocalTime?), SafeParse(ParseLocalTime));
parsers.Put(typeof(IEnumerable<string>), value => value);
parsers.Put(typeof(ICollection<string>), value => value);
parsers.Put(typeof(IList<string>), value => value);
parsers.Put(typeof(List<string>), value => value);
parsers.Put(typeof(ISet<string>), value => value);
parsers.Put(typeof(HashSet<string>), value => value);
parsers.Put(typeof(IEnumerable<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(ICollection<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(IList<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(List<bool>), ListParse(bool.Parse));
parsers.Put(typeof(ISet<bool>), ImmutableSetParse(bool.Parse));
parsers.Put(typeof(HashSet<bool>), SetParse(bool.Parse));
parsers.Put(typeof(IEnumerable<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(ICollection<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(IList<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(List<byte>), ListParse(byte.Parse));
parsers.Put(typeof(ISet<byte>), ImmutableSetParse(byte.Parse));
parsers.Put(typeof(HashSet<byte>), SetParse(byte.Parse));
parsers.Put(typeof(IEnumerable<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(ICollection<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(IList<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(List<sbyte>), ListParse(sbyte.Parse));
parsers.Put(typeof(ISet<sbyte>), ImmutableSetParse(sbyte.Parse));
parsers.Put(typeof(HashSet<sbyte>), SetParse(sbyte.Parse));
parsers.Put(typeof(IEnumerable<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(ICollection<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(IList<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(List<short>), ListParse(short.Parse));
parsers.Put(typeof(ISet<short>), ImmutableSetParse(short.Parse));
parsers.Put(typeof(HashSet<short>), SetParse(short.Parse));
parsers.Put(typeof(IEnumerable<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(ICollection<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(IList<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(List<ushort>), ListParse(ushort.Parse));
parsers.Put(typeof(ISet<ushort>), ImmutableSetParse(ushort.Parse));
parsers.Put(typeof(HashSet<ushort>), SetParse(ushort.Parse));
parsers.Put(typeof(IEnumerable<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(ICollection<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(IList<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(List<int>), ListParse(int.Parse));
parsers.Put(typeof(ISet<int>), ImmutableSetParse(int.Parse));
parsers.Put(typeof(HashSet<int>), SetParse(int.Parse));
parsers.Put(typeof(IEnumerable<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(ICollection<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(IList<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(List<uint>), ListParse(uint.Parse));
parsers.Put(typeof(ISet<uint>), ImmutableSetParse(uint.Parse));
parsers.Put(typeof(HashSet<uint>), SetParse(uint.Parse));
parsers.Put(typeof(IEnumerable<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(ICollection<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(IList<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(List<long>), ListParse(long.Parse));
parsers.Put(typeof(ISet<long>), ImmutableSetParse(long.Parse));
parsers.Put(typeof(HashSet<long>), SetParse(long.Parse));
parsers.Put(typeof(IEnumerable<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(ICollection<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(IList<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(List<ulong>), ListParse(ulong.Parse));
parsers.Put(typeof(ISet<ulong>), ImmutableSetParse(ulong.Parse));
parsers.Put(typeof(HashSet<ulong>), SetParse(ulong.Parse));
parsers.Put(typeof(IEnumerable<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(ICollection<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(IList<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(List<float>), ListParse(float.Parse));
parsers.Put(typeof(ISet<float>), ImmutableSetParse(float.Parse));
parsers.Put(typeof(HashSet<float>), SetParse(float.Parse));
parsers.Put(typeof(IEnumerable<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(ICollection<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(IList<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(List<double>), ListParse(double.Parse));
parsers.Put(typeof(ISet<double>), ImmutableSetParse(double.Parse));
parsers.Put(typeof(HashSet<double>), SetParse(double.Parse));
parsers.Put(typeof(IEnumerable<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(ICollection<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(IList<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(List<decimal>), ListParse(decimal.Parse));
parsers.Put(typeof(ISet<decimal>), ImmutableSetParse(decimal.Parse));
parsers.Put(typeof(HashSet<decimal>), SetParse(decimal.Parse));
parsers.Put(typeof(IEnumerable<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(ICollection<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(IList<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(List<DateTime>), ListParse(DateTime.Parse));
parsers.Put(typeof(ISet<DateTime>), ImmutableSetParse(DateTime.Parse));
parsers.Put(typeof(HashSet<DateTime>), SetParse(DateTime.Parse));
parsers.Put(typeof(IEnumerable<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(ICollection<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(IList<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(List<TimeSpan>), ListParse(TimeSpan.Parse));
parsers.Put(typeof(ISet<TimeSpan>), ImmutableSetParse(TimeSpan.Parse));
parsers.Put(typeof(HashSet<TimeSpan>), SetParse(TimeSpan.Parse));
return parsers.ToImmutableDictionary();
}
private static Func<Parameter, object> SafeParse<T>(Func<string, T> parse)
{
return parameter =>
{
try
{
return parse(parameter.Value);
}
catch (OverflowException)
{
throw ParameterOutOfRange(parameter, typeof(T));
}
catch (FormatException)
{
throw InvalidParameterFormat(parameter, typeof(T));
}
catch (Exception e)
{
throw new InvalidOperationException(Strings.Format("Unable to parse parameter: '{0}' with value: '{1}' to {2}",
parameter.Name, parameter.Value, typeof(T)), e);
}
};
}
private static Func<Parameter, object> ListParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return new List<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToList();
return results;
};
}
private static Func<Parameter, object> ImmutableListParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return Lists.EmptyList<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToImmutableList();
return results;
};
}
private static Func<Parameter, object> SetParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return new HashSet<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToSet();
return results;
};
}
private static Func<Parameter, object> ImmutableSetParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return Sets.EmptySet<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToImmutableHashSet();
return results;
};
}
private static ZonedDateTime ParseZonedDateTime(string value)
{
var dateTime = DateTime.Parse(value);
return new ZonedDateTime(Instant.FromDateTimeUtc(dateTime.ToUniversalTime()), DateTimeZone.Utc);
}
private static LocalTime ParseLocalTime(string value)
{
return LocalTimePattern.ExtendedIsoPattern.Parse(value).Value;
}
private static ArgumentException ParameterOutOfRange(Parameter parameter, Type type)
{
return new ArgumentException(Strings.Format("Query: '{0}' value: '{1}' is out of range for: '{2}'",
parameter.Name, parameter.Value, type));
}
private static ArgumentException InvalidParameterFormat(Parameter parameter, Type type)
{
return new ArgumentException(Strings.Format("Query '{0}' value: '{1}' format is invalid for: '{2}'",
parameter.Name, parameter.Value, type));
}
private class Parameter
{
internal string Name { get; private set; }
internal string Value { get; private set; }
private Parameter(string name, string value)
{
Name = name;
Value = value;
}
internal static Parameter Of(string name, string value)
{
return new Parameter(name, value);
}
}
}
internal enum ParameterType
{
Undefined,
Query,
Path,
Header
}
}

1
modules/swagger-codegen/src/main/resources/nancyfx/paramsList.mustache Normal file
View File

@ -0,0 +1 @@
{{#allParams}}{{#isEnum}}{{>innerApiEnumName}}?{{/isEnum}}{{^isEnum}}{{&dataType}}{{/isEnum}} {{paramName}}{{#hasMore}}, {{/hasMore}}{{/allParams}}

42
modules/swagger-codegen/src/test/java/io/swagger/codegen/options/NancyFXServerOptionsProvider.java Normal file
View File

@ -0,0 +1,42 @@
package io.swagger.codegen.options;
import static io.swagger.codegen.CodegenConstants.PACKAGE_NAME;
import static io.swagger.codegen.CodegenConstants.PACKAGE_VERSION;
import static io.swagger.codegen.CodegenConstants.RETURN_ICOLLECTION;
import static io.swagger.codegen.CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG;
import static io.swagger.codegen.CodegenConstants.SOURCE_FOLDER;
import static io.swagger.codegen.CodegenConstants.USE_COLLECTION;
import static io.swagger.codegen.CodegenConstants.USE_DATETIME_OFFSET;
import java.util.Map;
import com.google.common.collect.ImmutableMap;
public class NancyFXServerOptionsProvider implements OptionsProvider {
public static final String PACKAGE_NAME_VALUE = "swagger_server_nancyfx";
public static final String PACKAGE_VERSION_VALUE = "1.0.0-SNAPSHOT";
public static final String SOURCE_FOLDER_VALUE = "src_nancyfx";
@Override
public String getLanguage() {
return "nancyfx";
}
@Override
public Map<String, String> createOptions() {
final ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
return builder.put(PACKAGE_NAME, PACKAGE_NAME_VALUE)
.put(PACKAGE_VERSION, PACKAGE_VERSION_VALUE)
.put(SOURCE_FOLDER, SOURCE_FOLDER_VALUE)
.put(SORT_PARAMS_BY_REQUIRED_FLAG, "true")
.put(USE_DATETIME_OFFSET, "true")
.put(USE_COLLECTION, "false")
.put(RETURN_ICOLLECTION, "false")
.build();
}
@Override
public boolean isServer() {
return true;
}
}

25
samples/server/petstore/nancyfx/IO.Swagger.sln Normal file
View File

@ -0,0 +1,25 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2012
VisualStudioVersion = 12.0.0.0
MinimumVisualStudioVersion = 10.0.0.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IO.Swagger", "src\IO.Swagger\IO.Swagger.csproj", "{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}.Release|Any CPU.Build.0 = Release|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Debug|Any CPU.Build.0 = Debug|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Release|Any CPU.ActiveCfg = Release|Any CPU
{19F1DEBC-DE5E-4517-8062-F000CD499087}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

66
samples/server/petstore/nancyfx/src/IO.Swagger/IO.Swagger.csproj Normal file
View File

@ -0,0 +1,66 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{1DE2DD8D-1AFB-4BC2-9FB5-04DE7DCA1353}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>IO.Swagger.v2</RootNamespace>
<AssemblyName></AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Debug\IO.Swagger.XML</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>bin\Release\IO.Swagger.XML</DocumentationFile>
</PropertyGroup>
<ItemGroup>
<Reference Include="Nancy, Version=1.4.1.0, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\Nancy.1.4.1\lib\net40\Nancy.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="NodaTime, Version=1.3.0.0, Culture=neutral, PublicKeyToken=4226afe0d9b296d1, processorArchitecture=MSIL">
<HintPath>..\..\packages\NodaTime.1.3.1\lib\net35-Client\NodaTime.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="Sharpility, Version=1.2.1.0, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\..\packages\Sharpility.1.2.1\lib\net45\Sharpility.dll</HintPath>
<Private>True</Private>
</Reference>
<Reference Include="System.Collections.Immutable, Version=1.1.37.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<HintPath>..\..\packages\System.Collections.Immutable.1.1.37\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
<Private>True</Private>
</Reference> <Reference Include="System"/>
<Reference Include="System.Core"/>
<Reference Include="System.Xml.Linq"/>
<Reference Include="System.Data.DataSetExtensions"/>
<Reference Include="Microsoft.CSharp"/>
<Reference Include="System.Data"/>
<Reference Include="System.Runtime.Serialization"/>
<Reference Include="System.Xml"/>
</ItemGroup>
<ItemGroup>
<Compile Include="**\*.cs" Exclude="obj\**"/>
</ItemGroup>
<ItemGroup>
<Content Include="packages.config"/>
</ItemGroup>
<Import Project="$(MsBuildToolsPath)\Microsoft.CSharp.targets"/>
</Project>

14
samples/server/petstore/nancyfx/src/IO.Swagger/IO.Swagger.nuspec Normal file
View File

@ -0,0 +1,14 @@
<?xml version="1.0"?>
<package>
<metadata>
<id>IO.Swagger</id>
<title>IO.Swagger</title>
<version>1.0.0</version>
<authors>swagger-codegen</authors>
<owners>swagger-codegen</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>NancyFx IO.Swagger API</description>
<copyright>http://helloreverb.com/terms/</copyright>
<licenseUrl>http://www.apache.org/licenses/LICENSE-2.0.html</licenseUrl>
</metadata>
</package>

165
samples/server/petstore/nancyfx/src/IO.Swagger/Models/Category.cs Normal file
View File

@ -0,0 +1,165 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
namespace IO.Swagger.v2.Models
{
/// <summary>
/// Category
/// </summary>
public sealed class Category: IEquatable<Category>
{
/// <summary>
/// Id
/// </summary>
public long? Id { get; private set; }
/// <summary>
/// Name
/// </summary>
public string Name { get; private set; }
/// <summary>
/// Empty constructor required by some serializers.
/// Use Category.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public Category()
{
}
private Category(long? Id, string Name)
{
this.Id = Id;
this.Name = Name;
}
/// <summary>
/// Returns builder of Category.
/// </summary>
/// <returns>CategoryBuilder</returns>
public static CategoryBuilder Builder()
{
return new CategoryBuilder();
}
/// <summary>
/// Returns CategoryBuilder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>CategoryBuilder</returns>
public CategoryBuilder With()
{
return Builder()
.Id(Id)
.Name(Name);
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals(Category other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for (Category.
/// </summary>
/// <param name="left">Compared (Category</param>
/// <param name="right">Compared (Category</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == (Category left, Category right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for (Category.
/// </summary>
/// <param name="left">Compared (Category</param>
/// <param name="right">Compared (Category</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != (Category left, Category right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of Category.
/// </summary>
public sealed class CategoryBuilder
{
private long? _Id;
private string _Name;
internal CategoryBuilder()
{
SetupDefaults();
}
private void SetupDefaults()
{
}
/// <summary>
/// Sets value for Category.Id property.
/// </summary>
/// <param name="value">Id</param>
public CategoryBuilder Id(long? value)
{
_Id = value;
return this;
}
/// <summary>
/// Sets value for Category.Name property.
/// </summary>
/// <param name="value">Name</param>
public CategoryBuilder Name(string value)
{
_Name = value;
return this;
}
/// <summary>
/// Builds instance of Category.
/// </summary>
/// <returns>Category</returns>
public Category Build()
{
Validate();
return new Category(
Id: _Id,
Name: _Name
);
}
private void Validate()
{
}
}
}
}

246
samples/server/petstore/nancyfx/src/IO.Swagger/Models/Order.cs Normal file
View File

@ -0,0 +1,246 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
namespace IO.Swagger.v2.Models
{
/// <summary>
/// Order
/// </summary>
public sealed class Order: IEquatable<Order>
{
/// <summary>
/// Id
/// </summary>
public long? Id { get; private set; }
/// <summary>
/// PetId
/// </summary>
public long? PetId { get; private set; }
/// <summary>
/// Quantity
/// </summary>
public int? Quantity { get; private set; }
/// <summary>
/// ShipDate
/// </summary>
public ZonedDateTime? ShipDate { get; private set; }
/// <summary>
/// Order Status
/// </summary>
public StatusEnum? Status { get; private set; }
/// <summary>
/// Complete
/// </summary>
public bool? Complete { get; private set; }
/// <summary>
/// Empty constructor required by some serializers.
/// Use Order.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public Order()
{
}
private Order(long? Id, long? PetId, int? Quantity, ZonedDateTime? ShipDate, StatusEnum? Status, bool? Complete)
{
this.Id = Id;
this.PetId = PetId;
this.Quantity = Quantity;
this.ShipDate = ShipDate;
this.Status = Status;
this.Complete = Complete;
}
/// <summary>
/// Returns builder of Order.
/// </summary>
/// <returns>OrderBuilder</returns>
public static OrderBuilder Builder()
{
return new OrderBuilder();
}
/// <summary>
/// Returns OrderBuilder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>OrderBuilder</returns>
public OrderBuilder With()
{
return Builder()
.Id(Id)
.PetId(PetId)
.Quantity(Quantity)
.ShipDate(ShipDate)
.Status(Status)
.Complete(Complete);
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals(Order other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for (Order.
/// </summary>
/// <param name="left">Compared (Order</param>
/// <param name="right">Compared (Order</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == (Order left, Order right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for (Order.
/// </summary>
/// <param name="left">Compared (Order</param>
/// <param name="right">Compared (Order</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != (Order left, Order right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of Order.
/// </summary>
public sealed class OrderBuilder
{
private long? _Id;
private long? _PetId;
private int? _Quantity;
private ZonedDateTime? _ShipDate;
private StatusEnum? _Status;
private bool? _Complete;
internal OrderBuilder()
{
SetupDefaults();
}
private void SetupDefaults()
{
}
/// <summary>
/// Sets value for Order.Id property.
/// </summary>
/// <param name="value">Id</param>
public OrderBuilder Id(long? value)
{
_Id = value;
return this;
}
/// <summary>
/// Sets value for Order.PetId property.
/// </summary>
/// <param name="value">PetId</param>
public OrderBuilder PetId(long? value)
{
_PetId = value;
return this;
}
/// <summary>
/// Sets value for Order.Quantity property.
/// </summary>
/// <param name="value">Quantity</param>
public OrderBuilder Quantity(int? value)
{
_Quantity = value;
return this;
}
/// <summary>
/// Sets value for Order.ShipDate property.
/// </summary>
/// <param name="value">ShipDate</param>
public OrderBuilder ShipDate(ZonedDateTime? value)
{
_ShipDate = value;
return this;
}
/// <summary>
/// Sets value for Order.Status property.
/// </summary>
/// <param name="value">Order Status</param>
public OrderBuilder Status(StatusEnum? value)
{
_Status = value;
return this;
}
/// <summary>
/// Sets value for Order.Complete property.
/// </summary>
/// <param name="value">Complete</param>
public OrderBuilder Complete(bool? value)
{
_Complete = value;
return this;
}
/// <summary>
/// Builds instance of Order.
/// </summary>
/// <returns>Order</returns>
public Order Build()
{
Validate();
return new Order(
Id: _Id,
PetId: _PetId,
Quantity: _Quantity,
ShipDate: _ShipDate,
Status: _Status,
Complete: _Complete
);
}
private void Validate()
{
}
}
public enum StatusEnum { Placed, Approved, Delivered };
}
}

254
samples/server/petstore/nancyfx/src/IO.Swagger/Models/Pet.cs Normal file
View File

@ -0,0 +1,254 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
namespace IO.Swagger.v2.Models
{
/// <summary>
/// Pet
/// </summary>
public sealed class Pet: IEquatable<Pet>
{
/// <summary>
/// Id
/// </summary>
public long? Id { get; private set; }
/// <summary>
/// Category
/// </summary>
public Category Category { get; private set; }
/// <summary>
/// Name
/// </summary>
public string Name { get; private set; }
/// <summary>
/// PhotoUrls
/// </summary>
public List<string> PhotoUrls { get; private set; }
/// <summary>
/// Tags
/// </summary>
public List<Tag> Tags { get; private set; }
/// <summary>
/// pet status in the store
/// </summary>
public StatusEnum? Status { get; private set; }
/// <summary>
/// Empty constructor required by some serializers.
/// Use Pet.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public Pet()
{
}
private Pet(long? Id, Category Category, string Name, List<string> PhotoUrls, List<Tag> Tags, StatusEnum? Status)
{
this.Id = Id;
this.Category = Category;
this.Name = Name;
this.PhotoUrls = PhotoUrls;
this.Tags = Tags;
this.Status = Status;
}
/// <summary>
/// Returns builder of Pet.
/// </summary>
/// <returns>PetBuilder</returns>
public static PetBuilder Builder()
{
return new PetBuilder();
}
/// <summary>
/// Returns PetBuilder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>PetBuilder</returns>
public PetBuilder With()
{
return Builder()
.Id(Id)
.Category(Category)
.Name(Name)
.PhotoUrls(PhotoUrls)
.Tags(Tags)
.Status(Status);
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals(Pet other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for (Pet.
/// </summary>
/// <param name="left">Compared (Pet</param>
/// <param name="right">Compared (Pet</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == (Pet left, Pet right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for (Pet.
/// </summary>
/// <param name="left">Compared (Pet</param>
/// <param name="right">Compared (Pet</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != (Pet left, Pet right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of Pet.
/// </summary>
public sealed class PetBuilder
{
private long? _Id;
private Category _Category;
private string _Name;
private List<string> _PhotoUrls;
private List<Tag> _Tags;
private StatusEnum? _Status;
internal PetBuilder()
{
SetupDefaults();
}
private void SetupDefaults()
{
}
/// <summary>
/// Sets value for Pet.Id property.
/// </summary>
/// <param name="value">Id</param>
public PetBuilder Id(long? value)
{
_Id = value;
return this;
}
/// <summary>
/// Sets value for Pet.Category property.
/// </summary>
/// <param name="value">Category</param>
public PetBuilder Category(Category value)
{
_Category = value;
return this;
}
/// <summary>
/// Sets value for Pet.Name property.
/// </summary>
/// <param name="value">Name</param>
public PetBuilder Name(string value)
{
_Name = value;
return this;
}
/// <summary>
/// Sets value for Pet.PhotoUrls property.
/// </summary>
/// <param name="value">PhotoUrls</param>
public PetBuilder PhotoUrls(List<string> value)
{
_PhotoUrls = value;
return this;
}
/// <summary>
/// Sets value for Pet.Tags property.
/// </summary>
/// <param name="value">Tags</param>
public PetBuilder Tags(List<Tag> value)
{
_Tags = value;
return this;
}
/// <summary>
/// Sets value for Pet.Status property.
/// </summary>
/// <param name="value">pet status in the store</param>
public PetBuilder Status(StatusEnum? value)
{
_Status = value;
return this;
}
/// <summary>
/// Builds instance of Pet.
/// </summary>
/// <returns>Pet</returns>
public Pet Build()
{
Validate();
return new Pet(
Id: _Id,
Category: _Category,
Name: _Name,
PhotoUrls: _PhotoUrls,
Tags: _Tags,
Status: _Status
);
}
private void Validate()
{
if (_Name == null)
{
throw new ArgumentException("Name is a required property for Pet and cannot be null");
}
if (_PhotoUrls == null)
{
throw new ArgumentException("PhotoUrls is a required property for Pet and cannot be null");
}
}
}
public enum StatusEnum { Available, Pending, Sold };
}
}

165
samples/server/petstore/nancyfx/src/IO.Swagger/Models/Tag.cs Normal file
View File

@ -0,0 +1,165 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
namespace IO.Swagger.v2.Models
{
/// <summary>
/// Tag
/// </summary>
public sealed class Tag: IEquatable<Tag>
{
/// <summary>
/// Id
/// </summary>
public long? Id { get; private set; }
/// <summary>
/// Name
/// </summary>
public string Name { get; private set; }
/// <summary>
/// Empty constructor required by some serializers.
/// Use Tag.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public Tag()
{
}
private Tag(long? Id, string Name)
{
this.Id = Id;
this.Name = Name;
}
/// <summary>
/// Returns builder of Tag.
/// </summary>
/// <returns>TagBuilder</returns>
public static TagBuilder Builder()
{
return new TagBuilder();
}
/// <summary>
/// Returns TagBuilder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>TagBuilder</returns>
public TagBuilder With()
{
return Builder()
.Id(Id)
.Name(Name);
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals(Tag other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for (Tag.
/// </summary>
/// <param name="left">Compared (Tag</param>
/// <param name="right">Compared (Tag</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == (Tag left, Tag right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for (Tag.
/// </summary>
/// <param name="left">Compared (Tag</param>
/// <param name="right">Compared (Tag</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != (Tag left, Tag right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of Tag.
/// </summary>
public sealed class TagBuilder
{
private long? _Id;
private string _Name;
internal TagBuilder()
{
SetupDefaults();
}
private void SetupDefaults()
{
}
/// <summary>
/// Sets value for Tag.Id property.
/// </summary>
/// <param name="value">Id</param>
public TagBuilder Id(long? value)
{
_Id = value;
return this;
}
/// <summary>
/// Sets value for Tag.Name property.
/// </summary>
/// <param name="value">Name</param>
public TagBuilder Name(string value)
{
_Name = value;
return this;
}
/// <summary>
/// Builds instance of Tag.
/// </summary>
/// <returns>Tag</returns>
public Tag Build()
{
Validate();
return new Tag(
Id: _Id,
Name: _Name
);
}
private void Validate()
{
}
}
}
}

285
samples/server/petstore/nancyfx/src/IO.Swagger/Models/User.cs Normal file
View File

@ -0,0 +1,285 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Sharpility.Extensions;
using NodaTime;
namespace IO.Swagger.v2.Models
{
/// <summary>
/// User
/// </summary>
public sealed class User: IEquatable<User>
{
/// <summary>
/// Id
/// </summary>
public long? Id { get; private set; }
/// <summary>
/// Username
/// </summary>
public string Username { get; private set; }
/// <summary>
/// FirstName
/// </summary>
public string FirstName { get; private set; }
/// <summary>
/// LastName
/// </summary>
public string LastName { get; private set; }
/// <summary>
/// Email
/// </summary>
public string Email { get; private set; }
/// <summary>
/// Password
/// </summary>
public string Password { get; private set; }
/// <summary>
/// Phone
/// </summary>
public string Phone { get; private set; }
/// <summary>
/// User Status
/// </summary>
public int? UserStatus { get; private set; }
/// <summary>
/// Empty constructor required by some serializers.
/// Use User.Builder() for instance creation instead.
/// </summary>
[Obsolete]
public User()
{
}
private User(long? Id, string Username, string FirstName, string LastName, string Email, string Password, string Phone, int? UserStatus)
{
this.Id = Id;
this.Username = Username;
this.FirstName = FirstName;
this.LastName = LastName;
this.Email = Email;
this.Password = Password;
this.Phone = Phone;
this.UserStatus = UserStatus;
}
/// <summary>
/// Returns builder of User.
/// </summary>
/// <returns>UserBuilder</returns>
public static UserBuilder Builder()
{
return new UserBuilder();
}
/// <summary>
/// Returns UserBuilder with properties set.
/// Use it to change properties.
/// </summary>
/// <returns>UserBuilder</returns>
public UserBuilder With()
{
return Builder()
.Id(Id)
.Username(Username)
.FirstName(FirstName)
.LastName(LastName)
.Email(Email)
.Password(Password)
.Phone(Phone)
.UserStatus(UserStatus);
}
public override string ToString()
{
return this.PropertiesToString();
}
public override bool Equals(object obj)
{
return this.EqualsByProperties(obj);
}
public bool Equals(User other)
{
return Equals((object) other);
}
public override int GetHashCode()
{
return this.PropertiesHash();
}
/// <summary>
/// Implementation of == operator for (User.
/// </summary>
/// <param name="left">Compared (User</param>
/// <param name="right">Compared (User</param>
/// <returns>true if compared items are equals, false otherwise</returns>
public static bool operator == (User left, User right)
{
return Equals(left, right);
}
/// <summary>
/// Implementation of != operator for (User.
/// </summary>
/// <param name="left">Compared (User</param>
/// <param name="right">Compared (User</param>
/// <returns>true if compared items are not equals, false otherwise</returns>
public static bool operator != (User left, User right)
{
return !Equals(left, right);
}
/// <summary>
/// Builder of User.
/// </summary>
public sealed class UserBuilder
{
private long? _Id;
private string _Username;
private string _FirstName;
private string _LastName;
private string _Email;
private string _Password;
private string _Phone;
private int? _UserStatus;
internal UserBuilder()
{
SetupDefaults();
}
private void SetupDefaults()
{
}
/// <summary>
/// Sets value for User.Id property.
/// </summary>
/// <param name="value">Id</param>
public UserBuilder Id(long? value)
{
_Id = value;
return this;
}
/// <summary>
/// Sets value for User.Username property.
/// </summary>
/// <param name="value">Username</param>
public UserBuilder Username(string value)
{
_Username = value;
return this;
}
/// <summary>
/// Sets value for User.FirstName property.
/// </summary>
/// <param name="value">FirstName</param>
public UserBuilder FirstName(string value)
{
_FirstName = value;
return this;
}
/// <summary>
/// Sets value for User.LastName property.
/// </summary>
/// <param name="value">LastName</param>
public UserBuilder LastName(string value)
{
_LastName = value;
return this;
}
/// <summary>
/// Sets value for User.Email property.
/// </summary>
/// <param name="value">Email</param>
public UserBuilder Email(string value)
{
_Email = value;
return this;
}
/// <summary>
/// Sets value for User.Password property.
/// </summary>
/// <param name="value">Password</param>
public UserBuilder Password(string value)
{
_Password = value;
return this;
}
/// <summary>
/// Sets value for User.Phone property.
/// </summary>
/// <param name="value">Phone</param>
public UserBuilder Phone(string value)
{
_Phone = value;
return this;
}
/// <summary>
/// Sets value for User.UserStatus property.
/// </summary>
/// <param name="value">User Status</param>
public UserBuilder UserStatus(int? value)
{
_UserStatus = value;
return this;
}
/// <summary>
/// Builds instance of User.
/// </summary>
/// <returns>User</returns>
public User Build()
{
Validate();
return new User(
Id: _Id,
Username: _Username,
FirstName: _FirstName,
LastName: _LastName,
Email: _Email,
Password: _Password,
Phone: _Phone,
UserStatus: _UserStatus
);
}
private void Validate()
{
}
}
}
}

229
samples/server/petstore/nancyfx/src/IO.Swagger/Modules/PetModule.cs Normal file
View File

@ -0,0 +1,229 @@
using System;
using Nancy;
using Nancy.ModelBinding;
using System.Collections.Generic;
using Sharpility.Base;
using IO.Swagger.v2.Models;
using IO.Swagger.v2.Utils;
using NodaTime;
namespace IO.Swagger.v2.Modules
{
/// <summary>
/// Module processing requests of Pet domain.
/// </summary>
public sealed class PetModule : NancyModule
{
/// <summary>
/// Sets up HTTP methods mappings.
/// </summary>
/// <param name="service">Service handling requests</param>
public PetModule(PetService service) : base("/v2")
{
Post["/pet"] = parameters =>
{
var body = this.Bind<Pet>();
service.AddPet(Context, body);
return new Response { ContentType = "application/json"};
};
Delete["/pet/{petId}"] = parameters =>
{
var petId = Parameters.ValueOf<long?>(parameters, Context.Request, "petId", ParameterType.Path);
var apiKey = Parameters.ValueOf<string>(parameters, Context.Request, "apiKey", ParameterType.Header);
Preconditions.IsNotNull(petId, "Required parameter: 'petId' is missing at 'DeletePet'");
service.DeletePet(Context, petId, apiKey);
return new Response { ContentType = "application/json"};
};
Get["/pet/findByStatus"] = parameters =>
{
var status = Parameters.ValueOf<List<string>>(parameters, Context.Request, "status", ParameterType.Query);
return service.FindPetsByStatus(Context, status);
};
Get["/pet/findByTags"] = parameters =>
{
var tags = Parameters.ValueOf<List<string>>(parameters, Context.Request, "tags", ParameterType.Query);
return service.FindPetsByTags(Context, tags);
};
Get["/pet/{petId}"] = parameters =>
{
var petId = Parameters.ValueOf<long?>(parameters, Context.Request, "petId", ParameterType.Path);
Preconditions.IsNotNull(petId, "Required parameter: 'petId' is missing at 'GetPetById'");
return service.GetPetById(Context, petId);
};
Put["/pet"] = parameters =>
{
var body = this.Bind<Pet>();
service.UpdatePet(Context, body);
return new Response { ContentType = "application/json"};
};
Post["/pet/{petId}"] = parameters =>
{
var petId = Parameters.ValueOf<string>(parameters, Context.Request, "petId", ParameterType.Path);
var name = Parameters.ValueOf<string>(parameters, Context.Request, "name", ParameterType.Undefined);
var status = Parameters.ValueOf<string>(parameters, Context.Request, "status", ParameterType.Undefined);
Preconditions.IsNotNull(petId, "Required parameter: 'petId' is missing at 'UpdatePetWithForm'");
service.UpdatePetWithForm(Context, petId, name, status);
return new Response { ContentType = "application/json"};
};
Post["/pet/{petId}/uploadImage"] = parameters =>
{
var petId = Parameters.ValueOf<long?>(parameters, Context.Request, "petId", ParameterType.Path);
var additionalMetadata = Parameters.ValueOf<string>(parameters, Context.Request, "additionalMetadata", ParameterType.Undefined);
var file = Parameters.ValueOf<System.IO.Stream>(parameters, Context.Request, "file", ParameterType.Undefined);
Preconditions.IsNotNull(petId, "Required parameter: 'petId' is missing at 'UploadFile'");
service.UploadFile(Context, petId, additionalMetadata, file);
return new Response { ContentType = "application/json"};
};
}
}
/// <summary>
/// Service handling Pet requests.
/// </summary>
public interface PetService
{
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">Pet object that needs to be added to the store (optional)</param>
/// <returns></returns>
void AddPet(NancyContext context, Pet body);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="petId">Pet id to delete</param>
/// <param name="apiKey"> (optional)</param>
/// <returns></returns>
void DeletePet(NancyContext context, long? petId, string apiKey);
/// <summary>
/// Multiple status values can be provided with comma seperated strings
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="status">Status values that need to be considered for filter (optional, default to available)</param>
/// <returns>List&lt;Pet&gt;</returns>
List<Pet> FindPetsByStatus(NancyContext context, List<string> status);
/// <summary>
/// Muliple tags can be provided with comma seperated strings. Use tag1, tag2, tag3 for testing.
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="tags">Tags to filter by (optional)</param>
/// <returns>List&lt;Pet&gt;</returns>
List<Pet> FindPetsByTags(NancyContext context, List<string> tags);
/// <summary>
/// Returns a pet when ID &lt; 10. ID &gt; 10 or nonintegers will simulate API error conditions
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="petId">ID of pet that needs to be fetched</param>
/// <returns>Pet</returns>
Pet GetPetById(NancyContext context, long? petId);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">Pet object that needs to be added to the store (optional)</param>
/// <returns></returns>
void UpdatePet(NancyContext context, Pet body);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="petId">ID of pet that needs to be updated</param>
/// <param name="name">Updated name of the pet (optional)</param>
/// <param name="status">Updated status of the pet (optional)</param>
/// <returns></returns>
void UpdatePetWithForm(NancyContext context, string petId, string name, string status);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="petId">ID of pet to update</param>
/// <param name="additionalMetadata">Additional data to pass to server (optional)</param>
/// <param name="file">file to upload (optional)</param>
/// <returns></returns>
void UploadFile(NancyContext context, long? petId, string additionalMetadata, System.IO.Stream file);
}
/// <summary>
/// Abstraction of PetService.
/// </summary>
public abstract class AbstractPetService: PetService
{
public virtual void AddPet(NancyContext context, Pet body)
{
AddPet(body);
}
public virtual void DeletePet(NancyContext context, long? petId, string apiKey)
{
DeletePet(petId, apiKey);
}
public virtual List<Pet> FindPetsByStatus(NancyContext context, List<string> status)
{
return FindPetsByStatus(status);
}
public virtual List<Pet> FindPetsByTags(NancyContext context, List<string> tags)
{
return FindPetsByTags(tags);
}
public virtual Pet GetPetById(NancyContext context, long? petId)
{
return GetPetById(petId);
}
public virtual void UpdatePet(NancyContext context, Pet body)
{
UpdatePet(body);
}
public virtual void UpdatePetWithForm(NancyContext context, string petId, string name, string status)
{
UpdatePetWithForm(petId, name, status);
}
public virtual void UploadFile(NancyContext context, long? petId, string additionalMetadata, System.IO.Stream file)
{
UploadFile(petId, additionalMetadata, file);
}
protected abstract void AddPet(Pet body);
protected abstract void DeletePet(long? petId, string apiKey);
protected abstract List<Pet> FindPetsByStatus(List<string> status);
protected abstract List<Pet> FindPetsByTags(List<string> tags);
protected abstract Pet GetPetById(long? petId);
protected abstract void UpdatePet(Pet body);
protected abstract void UpdatePetWithForm(string petId, string name, string status);
protected abstract void UploadFile(long? petId, string additionalMetadata, System.IO.Stream file);
}
}

126
samples/server/petstore/nancyfx/src/IO.Swagger/Modules/StoreModule.cs Normal file
View File

@ -0,0 +1,126 @@
using System;
using Nancy;
using Nancy.ModelBinding;
using System.Collections.Generic;
using Sharpility.Base;
using IO.Swagger.v2.Models;
using IO.Swagger.v2.Utils;
using NodaTime;
namespace IO.Swagger.v2.Modules
{
/// <summary>
/// Module processing requests of Store domain.
/// </summary>
public sealed class StoreModule : NancyModule
{
/// <summary>
/// Sets up HTTP methods mappings.
/// </summary>
/// <param name="service">Service handling requests</param>
public StoreModule(StoreService service) : base("/v2")
{
Delete["/store/order/{orderId}"] = parameters =>
{
var orderId = Parameters.ValueOf<string>(parameters, Context.Request, "orderId", ParameterType.Path);
Preconditions.IsNotNull(orderId, "Required parameter: 'orderId' is missing at 'DeleteOrder'");
service.DeleteOrder(Context, orderId);
return new Response { ContentType = "application/json"};
};
Get["/store/inventory"] = parameters =>
{
return service.GetInventory(Context);
};
Get["/store/order/{orderId}"] = parameters =>
{
var orderId = Parameters.ValueOf<string>(parameters, Context.Request, "orderId", ParameterType.Path);
Preconditions.IsNotNull(orderId, "Required parameter: 'orderId' is missing at 'GetOrderById'");
return service.GetOrderById(Context, orderId);
};
Post["/store/order"] = parameters =>
{
var body = this.Bind<Order>();
return service.PlaceOrder(Context, body);
};
}
}
/// <summary>
/// Service handling Store requests.
/// </summary>
public interface StoreService
{
/// <summary>
/// For valid response try integer IDs with value &lt; 1000. Anything above 1000 or nonintegers will generate API errors
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="orderId">ID of the order that needs to be deleted</param>
/// <returns></returns>
void DeleteOrder(NancyContext context, string orderId);
/// <summary>
/// Returns a map of status codes to quantities
/// </summary>
/// <param name="context">Context of request</param>
/// <returns>Dictionary&lt;string, int?&gt;</returns>
Dictionary<string, int?> GetInventory(NancyContext context);
/// <summary>
/// For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="orderId">ID of pet that needs to be fetched</param>
/// <returns>Order</returns>
Order GetOrderById(NancyContext context, string orderId);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">order placed for purchasing the pet (optional)</param>
/// <returns>Order</returns>
Order PlaceOrder(NancyContext context, Order body);
}
/// <summary>
/// Abstraction of StoreService.
/// </summary>
public abstract class AbstractStoreService: StoreService
{
public virtual void DeleteOrder(NancyContext context, string orderId)
{
DeleteOrder(orderId);
}
public virtual Dictionary<string, int?> GetInventory(NancyContext context)
{
return GetInventory();
}
public virtual Order GetOrderById(NancyContext context, string orderId)
{
return GetOrderById(orderId);
}
public virtual Order PlaceOrder(NancyContext context, Order body)
{
return PlaceOrder(body);
}
protected abstract void DeleteOrder(string orderId);
protected abstract Dictionary<string, int?> GetInventory();
protected abstract Order GetOrderById(string orderId);
protected abstract Order PlaceOrder(Order body);
}
}

221
samples/server/petstore/nancyfx/src/IO.Swagger/Modules/UserModule.cs Normal file
View File

@ -0,0 +1,221 @@
using System;
using Nancy;
using Nancy.ModelBinding;
using System.Collections.Generic;
using Sharpility.Base;
using IO.Swagger.v2.Models;
using IO.Swagger.v2.Utils;
using NodaTime;
namespace IO.Swagger.v2.Modules
{
/// <summary>
/// Module processing requests of User domain.
/// </summary>
public sealed class UserModule : NancyModule
{
/// <summary>
/// Sets up HTTP methods mappings.
/// </summary>
/// <param name="service">Service handling requests</param>
public UserModule(UserService service) : base("/v2")
{
Post["/user"] = parameters =>
{
var body = this.Bind<User>();
service.CreateUser(Context, body);
return new Response { ContentType = "application/json"};
};
Post["/user/createWithArray"] = parameters =>
{
var body = this.Bind<List<User>>();
service.CreateUsersWithArrayInput(Context, body);
return new Response { ContentType = "application/json"};
};
Post["/user/createWithList"] = parameters =>
{
var body = this.Bind<List<User>>();
service.CreateUsersWithListInput(Context, body);
return new Response { ContentType = "application/json"};
};
Delete["/user/{username}"] = parameters =>
{
var username = Parameters.ValueOf<string>(parameters, Context.Request, "username", ParameterType.Path);
Preconditions.IsNotNull(username, "Required parameter: 'username' is missing at 'DeleteUser'");
service.DeleteUser(Context, username);
return new Response { ContentType = "application/json"};
};
Get["/user/{username}"] = parameters =>
{
var username = Parameters.ValueOf<string>(parameters, Context.Request, "username", ParameterType.Path);
Preconditions.IsNotNull(username, "Required parameter: 'username' is missing at 'GetUserByName'");
return service.GetUserByName(Context, username);
};
Get["/user/login"] = parameters =>
{
var username = Parameters.ValueOf<string>(parameters, Context.Request, "username", ParameterType.Query);
var password = Parameters.ValueOf<string>(parameters, Context.Request, "password", ParameterType.Query);
return service.LoginUser(Context, username, password);
};
Get["/user/logout"] = parameters =>
{
service.LogoutUser(Context);
return new Response { ContentType = "application/json"};
};
Put["/user/{username}"] = parameters =>
{
var username = Parameters.ValueOf<string>(parameters, Context.Request, "username", ParameterType.Path);
var body = this.Bind<User>();
Preconditions.IsNotNull(username, "Required parameter: 'username' is missing at 'UpdateUser'");
service.UpdateUser(Context, username, body);
return new Response { ContentType = "application/json"};
};
}
}
/// <summary>
/// Service handling User requests.
/// </summary>
public interface UserService
{
/// <summary>
/// This can only be done by the logged in user.
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">Created user object (optional)</param>
/// <returns></returns>
void CreateUser(NancyContext context, User body);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">List of user object (optional)</param>
/// <returns></returns>
void CreateUsersWithArrayInput(NancyContext context, List<User> body);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="body">List of user object (optional)</param>
/// <returns></returns>
void CreateUsersWithListInput(NancyContext context, List<User> body);
/// <summary>
/// This can only be done by the logged in user.
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="username">The name that needs to be deleted</param>
/// <returns></returns>
void DeleteUser(NancyContext context, string username);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="username">The name that needs to be fetched. Use user1 for testing. </param>
/// <returns>User</returns>
User GetUserByName(NancyContext context, string username);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="username">The user name for login (optional)</param>
/// <param name="password">The password for login in clear text (optional)</param>
/// <returns>string</returns>
string LoginUser(NancyContext context, string username, string password);
/// <summary>
///
/// </summary>
/// <param name="context">Context of request</param>
/// <returns></returns>
void LogoutUser(NancyContext context);
/// <summary>
/// This can only be done by the logged in user.
/// </summary>
/// <param name="context">Context of request</param>
/// <param name="username">name that need to be deleted</param>
/// <param name="body">Updated user object (optional)</param>
/// <returns></returns>
void UpdateUser(NancyContext context, string username, User body);
}
/// <summary>
/// Abstraction of UserService.
/// </summary>
public abstract class AbstractUserService: UserService
{
public virtual void CreateUser(NancyContext context, User body)
{
CreateUser(body);
}
public virtual void CreateUsersWithArrayInput(NancyContext context, List<User> body)
{
CreateUsersWithArrayInput(body);
}
public virtual void CreateUsersWithListInput(NancyContext context, List<User> body)
{
CreateUsersWithListInput(body);
}
public virtual void DeleteUser(NancyContext context, string username)
{
DeleteUser(username);
}
public virtual User GetUserByName(NancyContext context, string username)
{
return GetUserByName(username);
}
public virtual string LoginUser(NancyContext context, string username, string password)
{
return LoginUser(username, password);
}
public virtual void LogoutUser(NancyContext context)
{
LogoutUser();
}
public virtual void UpdateUser(NancyContext context, string username, User body)
{
UpdateUser(username, body);
}
protected abstract void CreateUser(User body);
protected abstract void CreateUsersWithArrayInput(List<User> body);
protected abstract void CreateUsersWithListInput(List<User> body);
protected abstract void DeleteUser(string username);
protected abstract User GetUserByName(string username);
protected abstract string LoginUser(string username, string password);
protected abstract void LogoutUser();
protected abstract void UpdateUser(string username, User body);
}
}

414
samples/server/petstore/nancyfx/src/IO.Swagger/Utils/Parameters.cs Normal file
View File

@ -0,0 +1,414 @@
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Nancy;
using NodaTime;
using NodaTime.Text;
using Sharpility.Base;
using Sharpility.Extensions;
using Sharpility.Util;
namespace IO.Swagger.v2.Utils
{
internal static class Parameters
{
private static readonly IDictionary<Type, Func<Parameter, object>> Parsers = CreateParsers();
internal static TValue ValueOf<TValue>(dynamic parameters, Request request, string name, ParameterType parameterType)
{
var valueType = typeof(TValue);
var valueUnderlyingType = Nullable.GetUnderlyingType(valueType);
var isNullable = default(TValue) == null;
string value = RawValueOf(parameters, request, name, parameterType);
Preconditions.Evaluate(!string.IsNullOrEmpty(value) || isNullable, string.Format("Required parameter: '{0}' is missing", name));
if (value == null && isNullable)
{
return default(TValue);
}
if (valueType.IsEnum || (valueUnderlyingType != null && valueUnderlyingType.IsEnum))
{
return EnumValueOf<TValue>(name, value);
}
return ValueOf<TValue>(parameters, name, value, valueType, request, parameterType);
}
private static string RawValueOf(dynamic parameters, Request request, string name, ParameterType parameterType)
{
try
{
switch (parameterType)
{
case ParameterType.Query:
string querValue = request.Query[name];
return querValue;
case ParameterType.Path:
string pathValue = parameters[name];
return pathValue;
case ParameterType.Header:
var headerValue = request.Headers[name];
return headerValue != null ? string.Join(",", headerValue) : null;
}
}
catch (Exception e)
{
throw new InvalidOperationException(string.Format("Could not obtain value of '{0}' parameter", name), e);
}
throw new InvalidOperationException(string.Format("Parameter with type: {0} is not supported", parameterType));
}
private static TValue EnumValueOf<TValue>(string name, string value)
{
var valueType = typeof(TValue);
var enumType = valueType.IsEnum ? valueType : Nullable.GetUnderlyingType(valueType);
Preconditions.IsNotNull(enumType, () => new InvalidOperationException(
string.Format("Could not parse parameter: '{0}' to enum. Type {1} is not enum", name, valueType)));
var values = Enum.GetValues(enumType);
foreach (var entry in values)
{
if (entry.ToString().EqualsIgnoreCases(value)
|| ((int)entry).ToString().EqualsIgnoreCases(value))
{
return (TValue)entry;
}
}
throw new ArgumentException(string.Format("Parameter: '{0}' value: '{1}' is not supported. Expected one of: {2}",
name, value, Strings.ToString(values)));
}
private static TValue ValueOf<TValue>(dynamic parameters, string name, string value, Type valueType, Request request, ParameterType parameterType)
{
var parser = Parsers.GetIfPresent(valueType);
if (parser != null)
{
return ParseValueUsing<TValue>(name, value, valueType, parser);
}
if (parameterType == ParameterType.Path)
{
return DynamicValueOf<TValue>(parameters, name);
}
if (parameterType == ParameterType.Query)
{
return DynamicValueOf<TValue>(request.Query, name);
}
throw new InvalidOperationException(string.Format("Could not get value for {0} with type {1}", name, valueType));
}
private static TValue ParseValueUsing<TValue>(string name, string value, Type valueType, Func<Parameter, object> parser)
{
var result = parser(Parameter.Of(name, value));
try
{
return (TValue)result;
}
catch (InvalidCastException)
{
throw new InvalidOperationException(
string.Format("Could not parse parameter: '{0}' with value: '{1}'. " +
"Received: '{2}', expected: '{3}'.",
name, value, result.GetType(), valueType));
}
}
private static TValue DynamicValueOf<TValue>(dynamic parameters, string name)
{
string value = parameters[name];
try
{
TValue result = parameters[name];
return result;
}
catch (InvalidCastException)
{
throw new InvalidOperationException(Strings.Format("Parameter: '{0}' value: '{1}' could not be parsed. " +
"Expected type: '{2}' is not supported",
name, value, typeof(TValue)));
}
catch (Exception e)
{
throw new InvalidOperationException(string.Format("Could not get '{0}' value of '{1}' type dynamicly",
name, typeof(TValue)), e);
}
}
private static IDictionary<Type, Func<Parameter, object>> CreateParsers()
{
var parsers = ImmutableDictionary.CreateBuilder<Type, Func<Parameter, object>>();
parsers.Put(typeof(string), value => value);
parsers.Put(typeof(bool), SafeParse(bool.Parse));
parsers.Put(typeof(bool?), SafeParse(bool.Parse));
parsers.Put(typeof(byte), SafeParse(byte.Parse));
parsers.Put(typeof(sbyte?), SafeParse(sbyte.Parse));
parsers.Put(typeof(short), SafeParse(short.Parse));
parsers.Put(typeof(short?), SafeParse(short.Parse));
parsers.Put(typeof(ushort), SafeParse(ushort.Parse));
parsers.Put(typeof(ushort?), SafeParse(ushort.Parse));
parsers.Put(typeof(int), SafeParse(int.Parse));
parsers.Put(typeof(int?), SafeParse(int.Parse));
parsers.Put(typeof(uint), SafeParse(uint.Parse));
parsers.Put(typeof(uint?), SafeParse(uint.Parse));
parsers.Put(typeof(long), SafeParse(long.Parse));
parsers.Put(typeof(long?), SafeParse(long.Parse));
parsers.Put(typeof(ulong), SafeParse(ulong.Parse));
parsers.Put(typeof(ulong?), SafeParse(ulong.Parse));
parsers.Put(typeof(float), SafeParse(float.Parse));
parsers.Put(typeof(float?), SafeParse(float.Parse));
parsers.Put(typeof(double), SafeParse(double.Parse));
parsers.Put(typeof(double?), SafeParse(double.Parse));
parsers.Put(typeof(decimal), SafeParse(decimal.Parse));
parsers.Put(typeof(decimal?), SafeParse(decimal.Parse));
parsers.Put(typeof(DateTime), SafeParse(DateTime.Parse));
parsers.Put(typeof(DateTime?), SafeParse(DateTime.Parse));
parsers.Put(typeof(TimeSpan), SafeParse(TimeSpan.Parse));
parsers.Put(typeof(TimeSpan?), SafeParse(TimeSpan.Parse));
parsers.Put(typeof(ZonedDateTime), SafeParse(ParseZonedDateTime));
parsers.Put(typeof(ZonedDateTime?), SafeParse(ParseZonedDateTime));
parsers.Put(typeof(LocalTime), SafeParse(ParseLocalTime));
parsers.Put(typeof(LocalTime?), SafeParse(ParseLocalTime));
parsers.Put(typeof(IEnumerable<string>), value => value);
parsers.Put(typeof(ICollection<string>), value => value);
parsers.Put(typeof(IList<string>), value => value);
parsers.Put(typeof(List<string>), value => value);
parsers.Put(typeof(ISet<string>), value => value);
parsers.Put(typeof(HashSet<string>), value => value);
parsers.Put(typeof(IEnumerable<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(ICollection<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(IList<bool>), ImmutableListParse(bool.Parse));
parsers.Put(typeof(List<bool>), ListParse(bool.Parse));
parsers.Put(typeof(ISet<bool>), ImmutableSetParse(bool.Parse));
parsers.Put(typeof(HashSet<bool>), SetParse(bool.Parse));
parsers.Put(typeof(IEnumerable<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(ICollection<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(IList<byte>), ImmutableListParse(byte.Parse));
parsers.Put(typeof(List<byte>), ListParse(byte.Parse));
parsers.Put(typeof(ISet<byte>), ImmutableSetParse(byte.Parse));
parsers.Put(typeof(HashSet<byte>), SetParse(byte.Parse));
parsers.Put(typeof(IEnumerable<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(ICollection<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(IList<sbyte>), ImmutableListParse(sbyte.Parse));
parsers.Put(typeof(List<sbyte>), ListParse(sbyte.Parse));
parsers.Put(typeof(ISet<sbyte>), ImmutableSetParse(sbyte.Parse));
parsers.Put(typeof(HashSet<sbyte>), SetParse(sbyte.Parse));
parsers.Put(typeof(IEnumerable<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(ICollection<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(IList<short>), ImmutableListParse(short.Parse));
parsers.Put(typeof(List<short>), ListParse(short.Parse));
parsers.Put(typeof(ISet<short>), ImmutableSetParse(short.Parse));
parsers.Put(typeof(HashSet<short>), SetParse(short.Parse));
parsers.Put(typeof(IEnumerable<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(ICollection<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(IList<ushort>), ImmutableListParse(ushort.Parse));
parsers.Put(typeof(List<ushort>), ListParse(ushort.Parse));
parsers.Put(typeof(ISet<ushort>), ImmutableSetParse(ushort.Parse));
parsers.Put(typeof(HashSet<ushort>), SetParse(ushort.Parse));
parsers.Put(typeof(IEnumerable<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(ICollection<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(IList<int>), ImmutableListParse(int.Parse));
parsers.Put(typeof(List<int>), ListParse(int.Parse));
parsers.Put(typeof(ISet<int>), ImmutableSetParse(int.Parse));
parsers.Put(typeof(HashSet<int>), SetParse(int.Parse));
parsers.Put(typeof(IEnumerable<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(ICollection<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(IList<uint>), ImmutableListParse(uint.Parse));
parsers.Put(typeof(List<uint>), ListParse(uint.Parse));
parsers.Put(typeof(ISet<uint>), ImmutableSetParse(uint.Parse));
parsers.Put(typeof(HashSet<uint>), SetParse(uint.Parse));
parsers.Put(typeof(IEnumerable<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(ICollection<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(IList<long>), ImmutableListParse(long.Parse));
parsers.Put(typeof(List<long>), ListParse(long.Parse));
parsers.Put(typeof(ISet<long>), ImmutableSetParse(long.Parse));
parsers.Put(typeof(HashSet<long>), SetParse(long.Parse));
parsers.Put(typeof(IEnumerable<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(ICollection<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(IList<ulong>), ImmutableListParse(ulong.Parse));
parsers.Put(typeof(List<ulong>), ListParse(ulong.Parse));
parsers.Put(typeof(ISet<ulong>), ImmutableSetParse(ulong.Parse));
parsers.Put(typeof(HashSet<ulong>), SetParse(ulong.Parse));
parsers.Put(typeof(IEnumerable<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(ICollection<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(IList<float>), ImmutableListParse(float.Parse));
parsers.Put(typeof(List<float>), ListParse(float.Parse));
parsers.Put(typeof(ISet<float>), ImmutableSetParse(float.Parse));
parsers.Put(typeof(HashSet<float>), SetParse(float.Parse));
parsers.Put(typeof(IEnumerable<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(ICollection<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(IList<double>), ImmutableListParse(double.Parse));
parsers.Put(typeof(List<double>), ListParse(double.Parse));
parsers.Put(typeof(ISet<double>), ImmutableSetParse(double.Parse));
parsers.Put(typeof(HashSet<double>), SetParse(double.Parse));
parsers.Put(typeof(IEnumerable<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(ICollection<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(IList<decimal>), ImmutableListParse(decimal.Parse));
parsers.Put(typeof(List<decimal>), ListParse(decimal.Parse));
parsers.Put(typeof(ISet<decimal>), ImmutableSetParse(decimal.Parse));
parsers.Put(typeof(HashSet<decimal>), SetParse(decimal.Parse));
parsers.Put(typeof(IEnumerable<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(ICollection<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(IList<DateTime>), ImmutableListParse(DateTime.Parse));
parsers.Put(typeof(List<DateTime>), ListParse(DateTime.Parse));
parsers.Put(typeof(ISet<DateTime>), ImmutableSetParse(DateTime.Parse));
parsers.Put(typeof(HashSet<DateTime>), SetParse(DateTime.Parse));
parsers.Put(typeof(IEnumerable<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(ICollection<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(IList<TimeSpan>), ImmutableListParse(TimeSpan.Parse));
parsers.Put(typeof(List<TimeSpan>), ListParse(TimeSpan.Parse));
parsers.Put(typeof(ISet<TimeSpan>), ImmutableSetParse(TimeSpan.Parse));
parsers.Put(typeof(HashSet<TimeSpan>), SetParse(TimeSpan.Parse));
return parsers.ToImmutableDictionary();
}
private static Func<Parameter, object> SafeParse<T>(Func<string, T> parse)
{
return parameter =>
{
try
{
return parse(parameter.Value);
}
catch (OverflowException)
{
throw ParameterOutOfRange(parameter, typeof(T));
}
catch (FormatException)
{
throw InvalidParameterFormat(parameter, typeof(T));
}
catch (Exception e)
{
throw new InvalidOperationException(Strings.Format("Unable to parse parameter: '{0}' with value: '{1}' to {2}",
parameter.Name, parameter.Value, typeof(T)), e);
}
};
}
private static Func<Parameter, object> ListParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return new List<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToList();
return results;
};
}
private static Func<Parameter, object> ImmutableListParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return Lists.EmptyList<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToImmutableList();
return results;
};
}
private static Func<Parameter, object> SetParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return new HashSet<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToSet();
return results;
};
}
private static Func<Parameter, object> ImmutableSetParse<T>(Func<string, T> itemParser)
{
return parameter =>
{
if (string.IsNullOrEmpty(parameter.Value))
{
return Sets.EmptySet<T>();
}
var results = parameter.Value.Split(new[] { ',' }, StringSplitOptions.None)
.Where(it => it != null)
.Select(it => it.Trim())
.Select(itemParser)
.ToImmutableHashSet();
return results;
};
}
private static ZonedDateTime ParseZonedDateTime(string value)
{
var dateTime = DateTime.Parse(value);
return new ZonedDateTime(Instant.FromDateTimeUtc(dateTime.ToUniversalTime()), DateTimeZone.Utc);
}
private static LocalTime ParseLocalTime(string value)
{
return LocalTimePattern.ExtendedIsoPattern.Parse(value).Value;
}
private static ArgumentException ParameterOutOfRange(Parameter parameter, Type type)
{
return new ArgumentException(Strings.Format("Query: '{0}' value: '{1}' is out of range for: '{2}'",
parameter.Name, parameter.Value, type));
}
private static ArgumentException InvalidParameterFormat(Parameter parameter, Type type)
{
return new ArgumentException(Strings.Format("Query '{0}' value: '{1}' format is invalid for: '{2}'",
parameter.Name, parameter.Value, type));
}
private class Parameter
{
internal string Name { get; private set; }
internal string Value { get; private set; }
private Parameter(string name, string value)
{
Name = name;
Value = value;
}
internal static Parameter Of(string name, string value)
{
return new Parameter(name, value);
}
}
}
internal enum ParameterType
{
Undefined,
Query,
Path,
Header
}
}

7
samples/server/petstore/nancyfx/src/IO.Swagger/packages.config Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Nancy" version="1.4.1" targetFramework="net45" />
<package id="NodaTime" version="1.3.1" targetFramework="net45" />
<package id="Sharpility" version="1.2.1" targetFramework="net45" />
<package id="System.Collections.Immutable" version="1.1.37" targetFramework="net45" />
</packages>