public void Can_read_non_existing_value_from_dictionary_via_dynamic_object()
{
var dictionary = new Dictionary<string, object>();
dynamic adapter = new DynamicDictionary(dictionary);
Assert.IsNull(adapter.Name);
}
public HomeModule(ITransient transient, IRequestScoped requestScoped)
: base("/home")
{
_transient = transient;
_requestScoped = requestScoped;
Debug.Assert(_requestScoped == _transient.RequestScoped);
Get["/"] = _ =>
{
var viewBag = new DynamicDictionary();
viewBag.Add("Transient", _transient);
viewBag.Add("RequestScoped", _requestScoped);
return View["home/index", viewBag];
};
Get["/index", runAsync: true] = async (_, token) =>
{
await Task.Delay(1000);
return "123";
};
Get["/list", runAsync: true] = async (_, token) =>
{
await Task.Delay(1);
return 500;
};
Get["/edit", runAsync: true] = async (_, token) =>
{
await Task.Delay(1);
return 404;
};
}
/// <summary>
/// Invokes the specified <paramref name="route"/> with the provided <paramref name="parameters"/>.
/// </summary>
/// <param name="route">The route that should be invoked.</param>
/// <param name="cancellationToken">Cancellation token</param>
/// <param name="parameters">The parameters that the route should be invoked with.</param>
/// <param name="context">The context of the route that is being invoked.</param>
/// <returns>A <see cref="Response"/> instance that represents the result of the invoked route.</returns>
public async Task<Response> Invoke(Route route, CancellationToken cancellationToken, DynamicDictionary parameters, NancyContext context)
{
object result;
try
{
result = await route.Invoke(parameters, cancellationToken).ConfigureAwait(false);
}
catch(RouteExecutionEarlyExitException earlyExitException)
{
context.WriteTraceLog(
sb => sb.AppendFormat(
"[DefaultRouteInvoker] Caught RouteExecutionEarlyExitException - reason {0}",
earlyExitException.Reason));
return earlyExitException.Response;
}
if (!(result is ValueType) && result == null)
{
context.WriteTraceLog(
sb => sb.AppendLine("[DefaultRouteInvoker] Invocation of route returned null"));
result = new Response();
}
return this.negotiator.NegotiateResponse(result, context);
}
public MainModule()
{
Get["/"] = x => View["index.html"];
Get["/login"] = x =>
{
dynamic model = new DynamicDictionary();
model.Errored = this.Request.Query.error.HasValue;
return View["login", model];
};
Post["/login"] = x =>
{
var userGuid = UserDatabase.ValidateUser((string)this.Request.Form.Username, (string)this.Request.Form.Password);
if (userGuid == null)
{
return this.Context.GetRedirect("~/login?error=true&username="******"/logout"] = x =>
{
return this.LogoutAndRedirect("~/");
};
}
public TmMqMessage( ITmMqMessage copy )
{
#region param checks
if( copy == null )
{
throw new ArgumentNullException( "copy" );
}
#endregion
MessageId = copy.MessageId;
Properties = new DynamicDictionary( copy.Properties );
Errors = new List<TmMqMessageError>( copy.Errors );
TimeStamp = copy.TimeStamp;
DeliveredAt = copy.DeliveredAt;
CorrelationId = copy.CorrelationId;
RetryCount = copy.RetryCount;
DeliveryCount = copy.DeliveryCount;
Type = copy.Type;
OriginalQueue = copy.OriginalQueue;
ReplyTo = copy.ReplyTo;
Text = copy.Text;
ExpireAt = copy.ExpireAt;
HoldUntil = copy.HoldUntil;
}
public void Test_get_cards_by_filter ()
{
DynamicDictionary query = new DynamicDictionary();
query.Add ("name", "Ankh of Mishra");
Card[] cards = repository.GetCards (query).Result;
Assert.Greater (cards.Length,1);
}
public void ShouldBeAbleToSetViaIndexerAndRetrieveViaDynamic()
{
dynamic dictionary = new DynamicDictionary();
dictionary["key"] = "value";
Assert.AreEqual("value", dictionary.key);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResolveResult"/> class, with
/// the provided <paramref name="route"/>, <paramref name="parameters"/>, <paramref name="before"/>,
/// <paramref name="after"/> and <paramref name="onError"/>.
/// </summary>
/// <param name="route">The request route instance.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="before">The before pipeline instance</param>
/// <param name="after">The after pipeline instace.</param>
/// <param name="onError">The on error interceptor instance.</param>
public ResolveResult(Route route, DynamicDictionary parameters, BeforePipeline before, AfterPipeline after, Func<NancyContext, Exception, dynamic> onError)
{
this.Route = route;
this.Parameters = parameters;
this.Before = before;
this.After = after;
this.OnError = onError;
}
public void PropertyShouldBeCaseInsensitive()
{
dynamic dictionary = new DynamicDictionary();
dictionary.key = "value";
Assert.AreEqual("value", dictionary.Key);
}
public RoutedRequest(IDictionary<string, object> env, Regex regex, string path)
: base(env)
{
var groups = regex.Match(path).Groups;
var dic = regex.GetGroupNames().ToDictionary(name => name, name => groups[name].Value);
UrlSegments = new DynamicDictionary<string>(dic);
}
public void Can_read_from_dictionary_via_dynamic_object()
{
var dictionary = new Dictionary<string, object>();
dynamic adapter = new DynamicDictionary(dictionary);
dictionary["Name"] = "stefan mucha";
Assert.AreEqual("stefan mucha", adapter.Name);
}
public void Can_add_to_dictionary_via_dynamic_object()
{
var dictionary = new Dictionary<string, object>();
dynamic adapter = new DynamicDictionary(dictionary);
adapter.Name = "stefan mucha";
Assert.AreEqual("stefan mucha", dictionary["Name"]);
}
public ResolveResult(Route route, DynamicDictionary parameters, Func<NancyContext, Response> before, Action<NancyContext> after, Func<NancyContext, Exception, Response> onError)
{
this.Route = route;
this.Parameters = parameters;
this.Before = before;
this.After = after;
this.OnError = onError;
}
public void ShouldBeAbleToSetAndRetrievePropertyViaIndexer()
{
var dictionary = new DynamicDictionary();
dictionary["key"] = "value";
Assert.AreEqual("value", dictionary["key"]);
}
public void A_Defined_Anonymous_Object_Should_Be_Accessible_Dynamically()
{
dynamic obj = new DynamicDictionary();
obj.Customer = new { FirstName = "Clark", LastName = "Kent" };
Assert.That( obj.Customer.FirstName == "Clark" );
}
public void Accessing_A_Not_Existent_Property_Should_Return_Null()
{
dynamic obj = new DynamicDictionary();
var firstName = obj.FirstName;
Assert.Null( firstName );
}
public void Accessing_A_Defined_Property_Should_Return_The_Defined_Value()
{
dynamic obj = new DynamicDictionary();
obj.FirstName = "Clark";
Assert.That( obj.FirstName == "Clark" );
}
public void The_DynamicDictionary_Should_Be_Castable_To_An_IDictionary_Of_String_Object()
{
dynamic obj = new DynamicDictionary();
var dictionary = (IDictionary<string, object>)obj;
Assert.NotNull( dictionary );
}
public void TestContainsKey()
{
var d = new DynamicDictionary();
d.Add("key", "value");
Assert.IsTrue(d.ContainsKey("key"), "Did not contain key: \"key\"");
}
public void TestAdd()
{
var d = new DynamicDictionary();
d.Add("key", "value");
Assert.AreEqual("value", d["key"]);
}
public void TestTryGetMemberKeyDoesNotExists()
{
var dynamicDictionary = new DynamicDictionary();
dynamic d = dynamicDictionary;
Assert.IsNull(d.foo);
}
/// <summary>
/// Gets a dynamic dictionary back from a Uri query string
/// </summary>
/// <param name="queryString">The query string to extract values from</param>
/// <returns>A dynamic dictionary containing the query string values</returns>
public static DynamicDictionary AsQueryDictionary(this string queryString)
{
var coll = HttpUtility.ParseQueryString(queryString);
var ret = new DynamicDictionary();
foreach (var key in coll.AllKeys.Where(key => key != null))
ret[key] = coll[key];
return ret;
}
public void Can_override_value_from_dictionary_via_dynamic_object()
{
var dictionary = new Dictionary<string, object>();
dynamic adapter = new DynamicDictionary(dictionary);
dictionary["Name"] = "adam mickiewicz";
adapter.Name = "stefan mucha";
Assert.AreEqual("stefan mucha", adapter.Name);
}
private IDictionary<string, object> GetDictionary(DynamicDictionary dynamicDictionary)
{
var result = new Dictionary<string, object>();
foreach (var item in dynamicDictionary)
{
result.Add(item, dynamicDictionary[item]);
}
return result;
}
public FakeRoute(dynamic response)
: base("GET", "/", null, x => response)
{
this.Action = x => {
this.ParametersUsedToInvokeAction = x;
this.ActionWasInvoked = true;
return response;
};
}
public HomeModule()
{
Get["/"] = _ =>
{
dynamic viewBag = new DynamicDictionary();
viewBag.WelcomeMessage = "Welcome to Nancy!";
return View["home", viewBag];
};
}
public void TestTryGetMemberKeyExists()
{
var dynamicDictionary = new DynamicDictionary();
dynamicDictionary["foo"] = "bar";
dynamic d = dynamicDictionary;
Assert.AreEqual("bar", d.foo);
}
public page1Module()
{
Get["/page1"] = _ =>
{
dynamic viewBag = new DynamicDictionary();
viewBag.Name = "Paul";
return View["page1", viewBag];
};
}
private static IDictionary<string, string> BuildQueryStringDictionary(DynamicDictionary queryString)
{
var d = new Dictionary<string, string>();
foreach (var key in queryString)
{
d.Add(key, queryString[key]);
}
return d;
}
public FakeRoutePatternMatchResult(Action<FakeRoutePatternMatchResultConfigurator> closure, DynamicDictionary parameters)
{
this.Parameters = parameters;
var configurator =
new FakeRoutePatternMatchResultConfigurator(this);
closure.Invoke(configurator);
}
/// <summary>
/// 创建卡券
/// </summary>
/// <param name="access_token">公众号access token</param>
/// <param name="card_type">卡券类型</param>
/// <param name="data">卡券数据</param>
/// <returns>data字段为card_id</returns>
public JsonResult <string> CreateCard(string access_token, string card_type, BaseCard data)
{
DynamicDictionary dic = new DynamicDictionary();
dic.SetMember("card_type", card_type?.ToUpper());
dic.SetMember(card_type?.ToLower(), data);
var obj = new
{
card = dic.GetMembers()
};
string url = $"{Config.WxApi}card/create?access_token={access_token}";
return(WxAPI.RequestData <string>(url, obj, Method.POST));
}
public void Should_return_true_when_trygetvalue_could_find_key()
{
// Given
var input = new DynamicDictionary();
input["test"] = 10;
object output;
// When
var result = input.TryGetValue("test", out output);
// Then
result.ShouldBeTrue();
}
public void Should_return_correct_count(int expectedNumberOfEntries)
{
// Given
var input = new DynamicDictionary();
// When
for (var i = 0; i < expectedNumberOfEntries; i++)
{
input[i.ToString(CultureInfo.InvariantCulture)] = i;
}
// Then
input.Count.ShouldEqual(expectedNumberOfEntries);
}
public void Should_support_GetDynamicMemberNames()
{
// Given
dynamic parameters = new DynamicDictionary();
parameters["test"] = "10";
parameters["rest"] = "20";
// When
var names = ((DynamicDictionary)parameters).GetDynamicMemberNames();
// Then
Assert.True(names.SequenceEqual(new[] { "test", "rest" }));
}
public void Should_return_response_when_route_returns_action()
{
// Given
Action <Stream> action = s => { };
var parameters = new DynamicDictionary();
var route = new FakeRoute(action);
var context = new NancyContext();
// When
var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result;
// Then
Assert.IsType <Response>(result);
}
public void Should_handle_RouteExecutionEarlyExitException_gracefully()
{
// Given
var response = new Response();
var route = new FakeRoute((c, t) => { throw new RouteExecutionEarlyExitException(response); });
var parameters = new DynamicDictionary();
var context = new NancyContext();
// When
var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result;
// Then
result.ShouldBeSameAs(response);
}
public void Should_remove_all_values_when_clear_is_invoked()
{
// Given
var input = new DynamicDictionary();
input["test1"] = 10;
input["test2"] = "test2";
// When
input.Clear();
// Then
input.Count.ShouldEqual(0);
}
public void TestTryGetValueKeyDoesNotExist()
{
var d = new DynamicDictionary();
object value;
Assert.IsFalse(
d.TryGetValue("key", out value),
"Expected false to trying to get a value for a non exisiting key.");
Assert.IsNull(
value,
"Retrieved a Non null value for a key that doesn't exist.");
}
/// <summary>
/// Fills the specified instance type with the contents of the dynamic dictionary
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="p"></param>
/// <returns></returns>
public static T Fill <T>(this DynamicDictionary p, T instance) where T : class
{
Type t = typeof(T);
t.GetProperties().ToList().ForEach(pi =>
{
if (p.Contains(pi.Name))
{
pi.SetValue(instance, p[pi.Name], new object[] { });
}
});
return(instance);
}
public void TestCount()
{
var d = new DynamicDictionary();
Assert.AreEqual(0, d.Count);
d.Add("key", "value");
Assert.AreEqual(1, d.Count);
d.Remove("key");
Assert.AreEqual(0, d.Count);
}
/// <summary>
/// Получить учетные цены в виде массива result[код товара]
/// </summary>
/// <param name="storageId">Код МХ</param>
/// <param name="articles">Список кодов товаров</param>
/// <param name="date">Дата</param>
/// <returns></returns>
public DynamicDictionary <int, decimal?> GetAccountingPrice(short storageId, IEnumerable <int> articles, DateTime date)
{
var result = new DynamicDictionary <int, decimal?>();
foreach (var item in articleAccountingPriceIndicatorService.GetList(new List <short>()
{
storageId
}, articles, date))
{
result[item.ArticleId] = item.AccountingPrice;
}
return(result);
}
public void TestTryGetValueKeyExists()
{
var d = new DynamicDictionary();
d.Add("key", "value");
object value;
Assert.IsTrue(
d.TryGetValue("key", out value),
"Expected true to trying to get a value for an existing key.");
Assert.AreEqual("value", value);
}
public void Should_support_dynamic_casting_of_nullable_properties()
{
//Given
dynamic parameters = new DynamicDictionary();
var guid = Guid.NewGuid();
parameters.test = guid.ToString();
// When
var value = (Guid?)parameters.test;
// Then
value.ShouldEqual(guid);
}
public static Tuple <string, string> login(DynamicDictionary x)
{
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2007_SP1);
Console.WriteLine(x["accountname"].ToString());
string pwd = EwsXenLib.security.decrypt(x["password"]);
bool logged = false;
string logintype = "";
if ((x["method"] == "basic") || (x["method"] == "exchange_ews_basic"))
{
logged = EwsXenLib.Program.Authenticate(x["accountname"], pwd, null, ref service);
logintype = "exchange_ews_basic";
}
else if (x["method"] == "exchange_ews_without_autodiscovery")
{
service.Url = new Uri(x["server"]);
logged = EwsXenLib.Program.Authenticate(x["accountname"], pwd, null, ref service);
logintype = "exchange_ews_without_autodiscovery";
}
else if (x["method"] == "exchange_ews_advanced")
{
service.Url = new System.Uri(x["server"]);
logged = EwsXenLib.Program.Authenticate(x["username"], pwd, x["domain"], ref service);
logintype = "exchange_ews_advanced";
}
else if (x["method"] == "advanced")
{
service.Url = new System.Uri(x["server"]);
logged = EwsXenLib.Program.Authenticate(x["accountname"], pwd, null, ref service);
logintype = "exchange_ews_without_autodiscovery";
if (!logged)
{
logged = EwsXenLib.Program.Authenticate(x["username"], pwd, x["domain"], ref service);
logintype = "exchange_ews_advanced";
}
}
string url = "";
string method = "";
if (logged == true)
{
method = logintype;
url = service.Url.ToString();
}
return(new Tuple <string, string>(method, url));
}
public Checkin CheckInPUT(User u, APISession session, DynamicDictionary parms)
{
Checkin t = this.Bind();
t.RegisteredBy = u.UserId;
// Check roles to see if the user can post
if (!u.IsAdmin() || t.UserId == 0)
{
t.UserId = u.UserId;
}
return(Checkin.CheckIn(t));
}
public void NullsAreEqual()
{
dynamic a1 = new DynamicDictionary();
a1.Field1 = null;
dynamic a2 = new DynamicDictionary();
a2.Field1 = null;
var comparer = new Comparer();
var isEqual = comparer.Compare(a1, a2);
Assert.IsTrue(isEqual);
}
public List <dynamic> GetAttachmentExt(string stGuidConnect, SVAOLLib.Card gCard, List <string> idAttachments, Boolean addBinary = true)
{
//Controllo se non è stato aperto già un File di Log
bool newcon = false;
//controllo se sono già connesso, in caso contrario mi connetto e ritorno la stringa di connessione
SVAOLLib.Session oSession = new SVAOLLib.Session();
oSession.GUIDconnect = stGuidConnect;
SVAOLLib.Attachment oAttachmentFrom = new SVAOLLib.Attachment();
oAttachmentFrom.GUIDconnect = stGuidConnect;
oAttachmentFrom.GuidCard = gCard.GuidCard;
dynamic objAttachment;
Object aBinaryData = new Object();
List <dynamic> objAttachments = new List <dynamic>();
try
{
int iCount;
object[,] attachments = (object[, ])gCard.AttachmentsAsArray;
for (iCount = 1; iCount < attachments.GetLength(0); iCount++)
{
if (Convert.ToInt32(attachments[iCount, 3]) == 0)
{
objAttachment = new DynamicDictionary();
objAttachment.id = attachments[iCount, 1].ToString();
objAttachment.nomefile = attachments[iCount, 4].ToString();
objAttachment.note = attachments[iCount, 2].ToString();
objAttachment.binarycontent = Convert.ToBase64String((byte[])(aBinaryData));
objAttachments.Add(objAttachment);
}
}
return(objAttachments);
}
catch (Exception e)
{
_Logger.WriteOnLog(_sLogId, "ERRORE NELL'ESECUZIONE DI : GetAttachmentExt", 1);
_Logger.WriteOnLog(_sLogId, e.Source + " " + e.Message, 1);
return(null);
throw new Exception(String.Format("{0}>>{1}>>{2}", "GetAttachmentExt", e.Source, e.Message), e);
}
finally
{
if (newcon)
{
oSession.Logout();
}
}
}
public virtual ResponseAuth Authenticate(int client_id, string username, string password)
{
//validate if data is passed with all 3 parameters.
ResponseAuth resp = new ResponseAuth();
if (client_id < 1)
{
resp.message = "Please select a Client.";
return(resp);
}
if (username.Trim().Length == 0)
{
resp.message = "Please enter a Username.";
return(resp);
}
if (password.Trim().Length == 0)
{
resp.message = "Please enter a Password.";
return(resp);
}
//var usermodel = Bango.Container.GetInstance<IUserModel>();
//UserService<UserModel, int?> userSrvc = (UserService<UserModel, int?>)Bango.Container.GetInstance(typeof(IUserService<UserModel, int?>));
var userSrvc = GetUserServiceInstance();
using (DbConnect con = new DbConnect())
{
resp = userSrvc.AuthenticateUserNamePasword(con, client_id, username, password);
//generate token
string token = string.Empty;
if (resp.success)
{
token = GenerateToken();
}
resp.token = token;
//save data in session & generate
SessionLogService sessionSrvc = new SessionLogService();
DynamicDictionary data_param = new DynamicDictionary();
data_param.Add("client_id", client_id);
data_param.Add("user_id", resp.user_id);
DateTime login_datetime = DateTime.Now;
data_param.Add("login_datetime", login_datetime);
data_param.Add("expire_datetime", GetExpirtyDateTime(login_datetime));
data_param.Add("token", token);
sessionSrvc.Insert(con, data_param);
//SessionLogModel
}
return(resp);
}
public void Should_return_dynamic_objects_as_objects()
{
//Given
var input = new DynamicDictionary();
input.Add("Test", new { Title = "Fred", Number = 123 });
//When
var result = input.ToDictionary();
//Then
Assert.Equal("Fred", ((dynamic)result["Test"]).Title);
Assert.Equal(123, ((dynamic)result["Test"]).Number);
}
public void Should_return_value_when_trygetvalue_could_find_key()
{
// Given
var input = new DynamicDictionary();
input["test"] = 10;
dynamic output;
// When
input.TryGetValue("test", out output);
// Then
((int)output).ShouldEqual(10);
}
public dynamic ToDynamic(DynamicDictionary data)
{
var eo = new ExpandoObject();
var eoColl = (ICollection <KeyValuePair <string, object> >)eo;
foreach (string key in data.KeyList)
{
eoColl.Add(new KeyValuePair <string, object>(key, data[key]));
}
dynamic eoDynamic = eo;
return(eoDynamic);
}
private IDictionary <string, object> ReadObject()
{
IDictionary <string, object> record = new DynamicDictionary();
// Consume the '{'
this.ReadCharFromReader();
while (true)
{
char ch = this.PeekNextSignificantCharacter();
if (ch == '\0')
{
throw new FormatException("Unterminated object literal.");
}
if (ch == '}')
{
this.ReadCharFromReader();
return(record);
}
if (record.Count != 0)
{
if (ch != ',')
{
throw new FormatException("Invalid object literal.");
}
else
{
this.ReadCharFromReader();
}
}
string name = this.ReadName(/* allowQuotes */ true);
ch = this.PeekNextSignificantCharacter();
if (ch != ':')
{
throw new FormatException("Unexpected name/value pair syntax in object literal.");
}
else
{
this.ReadCharFromReader();
}
object item = this.ReadValue();
record[name] = item;
}
}
public virtual BangoCommand GetSearchItemsCommand(DbConnect con, DynamicDictionary data_param, int page, int pageSize, string sort_by = null, bool count = false)
{
sort_by = sort_by == null ? string.Empty : sort_by;
TableDetailAttribute tableDetail = _model.GetTableDetail();
if (sort_by.Trim().Length == 0 && tableDetail.OrderByField != null && tableDetail.OrderByField.Length > 0)
{
sort_by = DbServiceUtility.SetColumnAlias(tableDetail.Alias, tableDetail.OrderByField);
}
BangoCommand cmd = GetSearchCommandTemplate(_model.GetAllFields(TableDetail.Alias, false), count, TableDetail.Alias);
return(GetSearchCommand(SearchScenario.Search, con, cmd, data_param, GetAllFields()
, sort_by, page, pageSize, count, TableDetail.Alias));
}
public void Should_return_all_values()
{
// Given
var input = new DynamicDictionary();
input["test1"] = 10;
input["test2"] = "test2";
// When
var result = input.Values;
// Then
result.ShouldHave(x => ((int)x).Equals(10));
result.ShouldHave(x => ((string)x).Equals("test2"));
}
public void Should_return_all_keys()
{
// Given
var input = new DynamicDictionary();
input["test1"] = 10;
input["test2"] = 10;
// When
var result = input.Keys;
// Then
result.ShouldHave(x => x.Equals("test1"));
result.ShouldHave(x => x.Equals("test2"));
}
public void Should_unwrap_dynamicdictionaryvalue_when_model_is_dynamicdictionary()
{
// Given
var model = new DynamicDictionary();
model["Name"] = "Nancy";
var drop = new DynamicDrop(model);
// When
var result = drop.BeforeMethod("Name");
// Then
result.ShouldBeOfType <string>();
}
public void Should_return_model_value_when_property_name_is_valid_and_model_is_dynamicdictionary()
{
// Given
var model = new DynamicDictionary();
model["Name"] = "Nancy";
var drop = new DynamicDrop(model);
// When
var result = drop.BeforeMethod("Name");
// Then
result.ShouldEqual("Nancy");
}
public void Should_return_null_when_called_with_invalid_property_name_and_model_is_dynamicdictionary()
{
// Given
var model = new DynamicDictionary();
model["Name"] = "Nancy";
var drop = new DynamicDrop(model);
// When
var result = drop.BeforeMethod("age");
// Then
result.ShouldBeNull();
}
private string IsAvailable(DynamicDictionary _parameters)
{
string username = _parameters["username"];
HydrantWikiManager hwm = new HydrantWikiManager();
User user = hwm.GetUser(UserSources.HydrantWiki, username);
if (user == null)
{
return("{ \"Available\":true }");
}
return("{ \"Available\":false }");
}
private ResolveResult BuildResult(NancyContext context, MatchResult result)
{
var associatedModule = this.GetModuleFromMatchResult(context, result);
var route = associatedModule.Routes.ElementAt(result.RouteIndex);
var parameters = DynamicDictionary.Create(result.Parameters);
return(new ResolveResult
{
Route = route,
Parameters = parameters,
Before = associatedModule.Before,
After = associatedModule.After,
OnError = associatedModule.OnError
});
}
