public void FunctionAsString()
{
DefinedFunction function = new DefinedFunction("foo", null, null, null);
Assert.AreEqual("<function foo>", ValueUtilities.AsString(function));
Assert.AreEqual("<function foo>", ValueUtilities.AsPrintString(function));
}
public object Apply(IContext context, IList <object> arguments, IDictionary <string, object> namedArguments)
{
string separator = (namedArguments != null && namedArguments.ContainsKey("sep")) ? (string)namedArguments["sep"] : " ";
string end = (namedArguments != null && namedArguments.ContainsKey("end")) ? (string)namedArguments["end"] : null;
if (arguments != null)
{
int narg = 0;
foreach (var argument in arguments)
{
if (narg != 0)
{
this.machine.Output.Write(separator);
}
this.machine.Output.Write(ValueUtilities.AsPrintString(argument));
narg++;
}
}
if (end != null)
{
this.machine.Output.Write(end);
}
else
{
this.machine.Output.WriteLine();
}
return(null);
}
public void ParseIntegral_Byte_Minimum_Integer_1()
{
var res = ValueUtilities.ParseIntegral("100", typeof(int));
Assert.IsInstanceOfType(res, typeof(int));
Assert.AreEqual(100, res);
}
public void ParseDecimal_0()
{
var res = ValueUtilities.ParseDecimals("15,3");
Assert.IsInstanceOfType(res, typeof(float));
Assert.AreEqual((float)15.3, res);
}
public ItemValueVariantBase ResolveToSingle(AnalysisContext context, IEnumerable <ItemValueVariantBase> variants)
{
var variantsArray = variants.ToArray();
switch (variantsArray.Length)
{
case 0:
Log.Debug("Unexpected 0 variants");
return(null);
case 1:
return(variantsArray[0]);
default:
{
var valueInterval = ValueUtilities.IterateValues(variantsArray.Select(x => x.Value),
ValueUtilities.IterateValuesOrFunc);
var indexes = variantsArray.Select(x => x.Index).Aggregate((current, next) => current | next);
var combinedVariant = new CombinedItemVariant(
valueInterval,
StorageVariable,
InnerTypeRef,
indexes,
variantsArray,
context);
return(combinedVariant);
}
}
}
public void CastTo_Double_1a()
{
var res = ValueUtilities.CastTo($"3{GetDecimalSeparator()}14", typeof(double));
Assert.IsInstanceOfType(res, typeof(double));
Assert.AreEqual(3.14, res);
}
/// <summary>
/// Matches an actual entity instance of a person against.
/// </summary>
/// <param name="actualEntityInstance">The actual entity instance to verify.</param>
/// <param name="expectedId">The expected id of the Person.</param>
/// <param name="expectedName">The expected name of the Person.</param>
/// <param name="expectedDateOfBirth">The expected date of birth of the person.</param>
/// <param name="expectedETag">The expected ETag of the entity instance.</param>
internal static void MatchEntityInstanceOfPerson(EntityInstance <Person> actualEntityInstance, string expectedId, string expectedName, string expectedDateOfBirth, string expectedETag)
{
Assert.AreEqual(expectedId, actualEntityInstance.Entity.Id);
Assert.AreEqual(ValueUtilities.GetNullableString(expectedName), actualEntityInstance.Entity.Name);
Assert.AreEqual(ValueUtilities.GetNullableDateTimeOffset(expectedDateOfBirth), actualEntityInstance.Entity.DateOfBirth);
Assert.AreEqual(ValueUtilities.GetNullableString(expectedETag), actualEntityInstance.ETag);
}
private void SolveConditionContexts(
[NotNull] GraphDataFlowConditionalNode node,
[NotNull] LogicExpressionBase expression,
[NotNull] GraphNode[] path)
{
var trueChanges = new List <(ValueVariantBase, IDataValue)>();
var falseChanges = new List <(ValueVariantBase, IDataValue)>();
if (!SolveExpression(node.EnterAnalysisContext, expression, trueChanges, falseChanges))
{
Log.Information("Logic: {Operator} -> {Expression}",
expression.Operator,
expression);
}
foreach (var grouping in trueChanges.GroupBy(x => x.Item1, x => x.Item2))
{
var(variant, dataValue) = (grouping.Key, grouping.ToArray());
var newVariant = variant.Clone(node.EnterAnalysisContext, path);
newVariant.Value = ValueUtilities.IterateValues(dataValue, variant.Value, dataValue.Length + 1,
ValueUtilities.IterateValuesAndFunc);
node.TrueExitAnalysisContext[variant] = newVariant;
}
foreach (var grouping in falseChanges.GroupBy(x => x.Item1, x => x.Item2))
{
var(variant, dataValue) = (grouping.Key, grouping.ToArray());
var newVariant = variant.Clone(node.EnterAnalysisContext, path);
newVariant.Value = ValueUtilities.IterateValues(dataValue, variant.Value, dataValue.Length + 1,
ValueUtilities.IterateValuesAndFunc);
node.FalseExitAnalysisContext[variant] = newVariant;
}
}
public void ClassAsString()
{
DefinedClass klass = new DefinedClass("Spam");
Assert.AreEqual("<class 'Spam'>", ValueUtilities.AsString(klass));
Assert.AreEqual("<class 'Spam'>", ValueUtilities.AsPrintString(klass));
}
public void EmptyListsAsString()
{
Assert.AreEqual("[]", ValueUtilities.AsPrintString(new ArrayList()));
Assert.AreEqual("[]", ValueUtilities.AsPrintString(new List <object>()
{
}));
Assert.AreEqual("()", ValueUtilities.AsPrintString(new List <object>().AsReadOnly()));
}
/// <summary>
/// Creates an entity instance from a person and an etag.
/// </summary>
/// <param name="person">The person to create.</param>
/// <param name="eTag">The etag for the instance.</param>
/// <param name="context">The scenario context.</param>
/// <param name="keyToSet">The key to set in the scenario context (or null if you do not wish to set the value into the context).</param>
/// <returns>The resulting <see cref="EntityInstance{T}"/> for the person.</returns>
internal static EntityInstance <Person> CreateEntityInstance(Person person, string eTag, ScenarioContext?context = null, string?keyToSet = null)
{
var entityInstance = new EntityInstance <Person>(person, ValueUtilities.GetNullableString(eTag));
if (context != null && keyToSet != null)
{
context.Set(entityInstance, keyToSet);
}
return(entityInstance);
}
/// <summary>
/// Creates a list of the specified element type and fills in the elements into the list.
/// </summary>
/// <param name="elementType">The element type of the list.</param>
/// <returns>The list.</returns>
private IList CreateList(Type elementType)
{
var genericType = typeof(List <>).MakeGenericType(elementType);
var list = (IList)Activator.CreateInstance(genericType);
foreach (var instanceProvider in _instanceProviders)
{
var instance = instanceProvider.GetInstance();
var castedInstance = ValueUtilities.CastTo(instance, elementType);
list.Add(castedInstance);
}
return(list);
}
public void ListsAsString()
{
Assert.AreEqual("[1, 2, 3]", ValueUtilities.AsPrintString(new ArrayList()
{
1, 2, 3
}));
Assert.AreEqual("['a', 'b', 'c']", ValueUtilities.AsPrintString(new List <object>()
{
"a", "b", "c"
}));
Assert.AreEqual("(1, 2, 'c')", ValueUtilities.AsPrintString((new List <object>()
{
1, 2, "c"
}).AsReadOnly()));
}
public static void Main(string[] args)
{
PythonSharp.Machine machine = new PythonSharp.Machine();
if (args != null && args.Length > 0)
{
if (ProcessFiles(args, machine))
{
return;
}
}
PrintIntro();
Parser parser = new Parser(System.Console.In);
while (true)
{
try
{
ICommand command = parser.CompileCommand();
if (command == null)
{
break;
}
if (command is ExpressionCommand)
{
IExpression expr = ((ExpressionCommand)command).Expression;
var value = expr.Evaluate(machine.Environment);
if (value != null)
{
Console.WriteLine(ValueUtilities.AsPrintString(value));
}
}
else
{
command.Execute(machine.Environment);
}
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
}
/// <summary>
/// Serialize a person to a document.
/// </summary>
/// <param name="person">The person to serialize.</param>
/// <param name="eTag">The etag for the document.</param>
/// <param name="context">The scenario context (or null if you do not wish to set the value into the context).</param>
/// <param name="keyToSet">The key to set in the scenario context (or null if you do not wish to set the value into the context).</param>
/// <returns>The serialized <see cref="Person"/>.</returns>
internal static string SerializePersonToDocument(Person person, string eTag, ScenarioContext?context = null, string?keyToSet = null)
{
string serializedPerson = JsonConvert.SerializeObject(person);
var jobject = JObject.Parse(serializedPerson);
jobject["_etag"] = ValueUtilities.GetNullableString(eTag);
string serializedDocument = jobject.ToString();
if (context != null && keyToSet != null)
{
context.Set(serializedDocument, keyToSet);
}
return(serializedDocument);
}
public override VariableValueVariantBase Create(AnalysisContext context)
{
var arrayVariant = Values[0].Clone(context);
foreach (var index in arrayVariant.IndexRange.Iterate(IntegerLiteral.One))
{
var variants = Values.Select(x => x[context, index]).ToArray();
var itemVariant = variants[0].Clone(context);
itemVariant.Value = ValueUtilities.IterateValues(
variants.Select(x => x.Value),
ValueUtilities.IterateValuesOrFunc);
if (!Equals(itemVariant.Value, arrayVariant[context, index].Value))
{
arrayVariant[context, index] = itemVariant;
}
}
return(arrayVariant);
}
private static SimpleInstanceProvider ParseSimpleInstanceElement(XElement xSimpleInstance)
{
var xValue = xSimpleInstance.Value;
var typeName = xSimpleInstance.Attribute("type")?.Value;
if (typeName == null)
{
try
{
return(new SimpleInstanceProvider(ValueUtilities.Parse(xValue)));
}
catch (Exception ex)
{
throw new XmlException(xSimpleInstance, ex);
}
}
var value = ValueUtilities.ParseToType(xValue, typeName);
return(new SimpleInstanceProvider(value));
}
public void NoneAsPrintString()
{
Assert.AreEqual("None", ValueUtilities.AsPrintString(null));
}
public void BooleansAsPrintString()
{
Assert.AreEqual("True", ValueUtilities.AsPrintString(true));
Assert.AreEqual("False", ValueUtilities.AsPrintString(false));
}
public void ParseIntegral_Byte_4()
{
var res = ValueUtilities.ParseIntegral("1000");
Assert.IsNotInstanceOfType(res, typeof(byte));
}
public void ParseIntegral_Byte_3()
{
var res = ValueUtilities.ParseIntegral("255");
Assert.AreEqual((byte)255, res);
}
public void ParseIntegral_Byte_1()
{
var res = ValueUtilities.ParseIntegral("128");
Assert.AreEqual((byte)128, res);
}
public void ParseIntegral_SByte_3()
{
var res = ValueUtilities.ParseIntegral("128");
Assert.IsNotInstanceOfType(res, typeof(sbyte));
}
public void ParseIntegral_SByte_2()
{
var res = ValueUtilities.ParseIntegral("127");
Assert.AreEqual((sbyte)127, res);
}
public void CastTo_Double_1b()
{
var res = ValueUtilities.CastTo <double>($"3{GetDecimalSeparator()}14");
Assert.AreEqual(3.14, res);
}
public void ParseIntegral_SByte_1()
{
var res = ValueUtilities.ParseIntegral("-1");
Assert.AreEqual((sbyte)-1, res);
}
public void IntegerAsPrintString()
{
Assert.AreEqual("1", ValueUtilities.AsPrintString(1));
}
public void StringAsPrintString()
{
Assert.AreEqual("spam", ValueUtilities.AsPrintString("spam"));
}
//public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
//{
// throw new NotImplementedException();
//}
public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
{
#region Check valid username
if (!SecurityUtility.IsUsernameValid(username))
{
status = MembershipCreateStatus.InvalidUserName;
return(null);
}
#endregion
#region Check for valid PersonId
string _username = username;
string _domain = string.Empty;
try
{
if (SecurityUtility.UsernameContainsDomain(username))
{
_username = SecurityUtility.ExtractUsername(username);
_domain = SecurityUtility.ExtractDomain(username);
}
}
catch
{
// Username was flagged as having a domain attached, but the extraction failed for unknown reason
status = MembershipCreateStatus.InvalidUserName;
return(null);
}
Guid personId;
bool locked = false;
try
{
if (providerUserKey != null && providerUserKey.ToString().Length >= 32)
{
personId = new Guid(providerUserKey.ToString().Substring(0, 32));
locked = ValueUtilities.GetBoolean(providerUserKey.ToString().Substring(32), false);
}
else if (providerUserKey == null || providerUserKey.ToString().Length == 0)
{
personId = Guid.Empty;
}
else
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return(null);
}
}
catch
{
status = MembershipCreateStatus.InvalidProviderUserKey;
return(null);
}
#endregion
#region Test for valid email
//if ((RequiresUniqueEmail || EnablePasswordRetrieval || EnablePasswordReset) && !password.Equals(SOCIAL_LOGIN_DEFAULT_PASSWORD))
//{
// if (email == null || EmailUtilities.ValidateEmailAddress(email) == false)
// {
// status = MembershipCreateStatus.InvalidEmail;
// return null;
// }
//}
#endregion
#region Test for valid password
if (!SecurityUtility.IsPasswordValid(password))
{
status = MembershipCreateStatus.InvalidPassword;
return(null);
}
#endregion
IRepositoryProvider _repositoryProvider = new RepositoryProvider(new RepositoryFactories());
var unitofWork = new UnitOfWork(new MisukaDBContext(), _repositoryProvider);
#region Check for unique username
Domain.Entity.User user = unitofWork.Repository <User>().Query(u => String.Compare(u.UserName, username, StringComparison.InvariantCultureIgnoreCase) == 0).Select().FirstOrDefault();
if (user != null)
{
status = MembershipCreateStatus.DuplicateUserName;
return(null);
}
#endregion
#region Test for valid question/answer
if (RequiresQuestionAndAnswer)
{
if (passwordQuestion == null || passwordQuestion.Length > 200 || passwordQuestion.Length < 1)
{
status = MembershipCreateStatus.InvalidQuestion;
return(null);
}
if (passwordAnswer == null || passwordAnswer.Length > 200 || passwordAnswer.Length < 1)
{
status = MembershipCreateStatus.InvalidAnswer;
return(null);
}
}
#endregion
DateTime dt = DateTime.Now;
user = new User
{
UserName = _username,
CreationDate = dt,
Domain = _domain,
PersonId = personId,
Locked = locked,
FailedLoginTimes = 0,
CurrentLanguage = System.Threading.Thread.CurrentThread.CurrentCulture.ToString()
};
user.Password = Cryptography.EncryptPassword(password, user.Salt);
try
{
unitofWork.RepositoryAsync <Domain.Entity.User>().Insert(user);
unitofWork.SaveChanges();
}
catch
{
status = MembershipCreateStatus.UserRejected;
// Log.Debug(this, string.Format("Create new user: {0} - failed", identity.Username));
return(null);
}
status = MembershipCreateStatus.Success;
//Log.Debug(this, string.Format("Create new user: {0} - successfully", identity.Username));
return(new MembershipUser(_providerName, username, providerUserKey, email, passwordQuestion, "", isApproved, false, dt, dt, dt, dt, DateTime.MinValue));
}
public CustomMembershipProvider()
{
_requiresUniqueEmail = true;
_applicationName = "/";
_enablePasswordReset = false;
_enablePasswordRetrieval = false;
_maxInvalidPasswordAttempts = 0;
_requiresQuestionAndAnswer = true;
_minRequiredNonAlphanumericCharacters = 0;
_minRequiredPasswordLength = 6;
_passwordAttemptWindow = 5;
_passwordFormat = MembershipPasswordFormat.Hashed;
_passwordStrengthRegularExpression = "";
ProviderSettings providerSettings = SecurityUtility.GetMembershipProviderSettings();
_providerName = providerSettings.Name;
foreach (string index in providerSettings.Parameters.AllKeys)
{
switch (index.ToLower())
{
case "applicationname":
_applicationName = providerSettings.Parameters[index];
break;
case "enablepasswordreset":
_enablePasswordReset = ValueUtilities.GetBoolean(providerSettings.Parameters[index], false);
break;
case "enablepasswordretrieval":
_enablePasswordRetrieval = ValueUtilities.GetBoolean(providerSettings.Parameters[index], false);
break;
case "maxinvalidpasswordattempts":
_maxInvalidPasswordAttempts = ValueUtilities.GetInt32(providerSettings.Parameters[index], 5);
break;
case "minrequirednonalphanumericcharacters":
_minRequiredNonAlphanumericCharacters = ValueUtilities.GetInt32(providerSettings.Parameters[index], 3);
break;
case "minrequiredpasswordlength":
_minRequiredPasswordLength = ValueUtilities.GetInt32(providerSettings.Parameters[index], 8);
break;
case "passwordattemptwindow":
_passwordAttemptWindow = ValueUtilities.GetInt32(providerSettings.Parameters[index], 5);
break;
case "passwordformat":
_passwordFormat = ValueUtilities.GetEnumerationValue <MembershipPasswordFormat>(providerSettings.Parameters[index]);
break;
case "passwordstrengthregularexpression":
_passwordStrengthRegularExpression = providerSettings.Parameters[index] ?? string.Empty;
break;
case "requiresquestionandanswer":
_requiresQuestionAndAnswer = ValueUtilities.GetBoolean(providerSettings.Parameters[index], true);
break;
case "requiresuniqueemail":
_requiresUniqueEmail = ValueUtilities.GetBoolean(providerSettings.Parameters[index], true);
break;
}
}
}
