public IUserOption DeserialiseVirtualProperty(XmlNode virtualPropertyNode)
{
NodeProcessor proc = new NodeProcessor(virtualPropertyNode);
string name = proc.Attributes.GetString("name");
string typeName = proc.Attributes.GetString("type");
Type type = GetTypeNamed(typeName);
if (type == null)
{
throw new Exception(string.Format("Could not find type named \"{0}\" for virtual property {1}", typeName, name));
}
string valueString = proc.GetString("Value");
IUserOption option = new UserOption();
option.Name = name;
option.DataType = type;
if (type == TypePropertiesForThisEntity)
{
option.Value = valueString;
}
else
{
option.Value = valueString.As(option.DataType);
}
return(option);
}
public UserOption CreateUserOption(string userId, bool onlyActiveStation, bool groupByState, string selectedSortParametr)
{
var userOption = new UserOption()
{
UserId = userId,
OnlyActiveStations = onlyActiveStation,
GroupByState = groupByState,
SelectedSortParametrs = selectedSortParametr
};
db.UserOptions.Add(userOption);
try
{
db.SaveChanges();
}
catch (System.Data.Entity.Validation.DbEntityValidationException dbEx)
{
Exception raise = dbEx;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
string message = $"{validationErrors.Entry.Entity}:{validationError.ErrorMessage}";
raise = new InvalidOperationException(message, raise);
}
}
}
return(userOption);
}
public GetLessonsRequest(UserOption user, DateTimeOffset startDate, DateTimeOffset endDate, int locationId)
: base(user)
{
StartDate = startDate;
EndDate = endDate;
LocationId = locationId;
}
public List <Backer> FindBackerByName(UserOption backerOption)
{
return(db.Backers
.Where(cust => cust.LastName == backerOption.LastName)
.Where(cust => cust.FirstName == backerOption.FirstName)
.ToList());
}
static void Main(string[] args)
{
Console.WriteLine("Welcome to the test area of the CrowdFunding website!");
//var userOpt = new UserOption()
//{
// FirstName = "Firstname",
// LastName = "Lastname",
// Email = "*****@*****.**",
// Password = "******",
// Dob = DateTime.Today
//};
//Console.WriteLine($"{userOpt.FirstName} {userOpt.LastName} {userOpt.Dob} {userOpt.Email}");
UserOption userOption = new UserOption
{
FirstName = "Nick",
LastName = "Giggs",
Dob = new DateTime(1994, 5, 14),
CreatedDate = DateTime.Now
};
UserService cs = new UserService();
cs.CreateUser(userOption);
Console.WriteLine("{0} {1},Date of Birth: {2},Created on {3}", userOption.FirstName, userOption.LastName, userOption.Dob, userOption.CreatedDate);
}
private TabItem CreateNewFunctionTabPage(UserOption userOption, FunctionTypes functionType, bool allowEdit)
{
var newPage = new TabItem();
var panel = new TabControlPanel { TabItem = newPage, Dock = DockStyle.Fill };
newPage.AttachedControl = panel;
switch (functionType)
{
case FunctionTypes.DefaultValue:
newPage.Text = userOption.VariableName + " [Default Value]";
break;
case FunctionTypes.DisplayToUser:
newPage.Text = userOption.VariableName + " [Display To User]";
break;
case FunctionTypes.Validation:
newPage.Text = userOption.VariableName + " [Valitation]";
break;
}
newPage.ImageIndex = 0;
newPage.Tag = userOption;
newPage.CloseButtonVisible = true;
var funcPanel = new ucFunction
{
Dock = DockStyle.Fill,
AllowEdit = allowEdit
};
newPage.AttachedControl.Controls.Add(funcPanel);
funcPanel.FunctionName = userOption.VariableName;
funcPanel.CurrentUserOption = userOption;
funcPanel.CurrentUserOptionFunctionType = functionType;
funcPanel.Populate();
newPage.ImageIndex = 0;
return newPage;
}
public List <ProjectCreator> FindProjectCreatorByName(UserOption projCreatOption)
{
return(db.ProjectCreators
.Where(cust => cust.LastName == projCreatOption.LastName)
.Where(cust => cust.FirstName == projCreatOption.FirstName)
.ToList());
}
public Backer UpdateBacker(UserOption backerOption, int backerId)
{
Backer backer = db.Backers.Find(backerId);
if (backerOption.FirstName != null)
{
backer.FirstName = backerOption.FirstName;
}
if (backerOption.LastName != null)
{
backer.LastName = backerOption.LastName;
}
if (backerOption.Email != null)
{
backer.Email = backerOption.Email;
}
if (backerOption.Username != null)
{
backer.Username = backerOption.Username;
}
if (backerOption.Password != null)
{
backer.Password = backerOption.Password;
}
if (backerOption.Dob != new DateTime())
{
backer.Dob = backerOption.Dob;
}
db.SaveChanges();
return(backer);
}
public User CreateUser(UserOption userOption)
{
//validation
if (userOption == null)
{
return(null);
}
if (userOption.FirstName == null)
{
return(null);
}
User user = new User
{
FirstName = userOption.FirstName,
LastName = userOption.LastName,
Email = userOption.Email
};
//dbContext.Customers.Add(customer);
// dbContext.SaveChanges();
return(new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
});
}
public ProjectCreator Update(UserOption projCreatOption, int projCrId)
{
ProjectCreator projectCreator = db.ProjectCreators.Find(projCrId);
if (projCreatOption.FirstName != null)
{
projectCreator.FirstName = projCreatOption.FirstName;
}
if (projCreatOption.LastName != null)
{
projectCreator.LastName = projCreatOption.LastName;
}
if (projCreatOption.Email != null)
{
projectCreator.Email = projCreatOption.Email;
}
if (projCreatOption.Username != null)
{
projectCreator.Username = projCreatOption.Username;
}
if (projCreatOption.Password != null)
{
projectCreator.Password = projCreatOption.Password;
}
if (projCreatOption.Dob != new DateTime())
{
projectCreator.Dob = projCreatOption.Dob;
}
db.SaveChanges();
return(projectCreator);
}
private void LoginButton_Click(object sender, RoutedEventArgs e)
{
var user = UserOption.UserLoginValidation(UserNameTextBox.Text,
UserPasswordTextBox.Password);
if (user == null)
{
MessageBox.Show("Невалидно потребителско име или патола");
}
else if (user.UserRole.Equals(Role.Admin))
{
//Opens Admin Window with adminUser
new AdminWindow(user).Show();
Close();
}
else if (user.UserRole.Equals(Role.Owner))
{
//Opens Owner Window with ownerUser
Close();
}
else if (user.UserRole.Equals(Role.Employee))
{
//Opens Employee Window with employeeUser
new EmployeeWindow(user).Show();
Close();
}
}
public void WriteUserOptionXML(UserOption option, XmlWriter writer)
{
writer.WriteStartElement("Option");
{
writer.WriteAttributeString("version", "1");
writer.WriteElementString("VariableName", option.VariableName);
writer.WriteElementString("Type", option.VarType.FullName);
writer.WriteElementString("DisplayText", option.Text);
writer.WriteElementString("Description", option.Description);
writer.WriteElementString("DefaultValue", option.DefaultValueFunctionBody);
writer.WriteElementString("IteratorName", option.IteratorType == null ? "" : option.IteratorType.FullName);
writer.WriteElementString("ValidatorFunction", option.ValidatorFunctionBody);
writer.WriteElementString("DisplayToUserFunction", option.DisplayToUserFunctionBody);
writer.WriteElementString("ResetPerSession", option.ResetPerSession.ToString());
writer.WriteStartElement("Values");
{
foreach (string optionValue in option.Values.OrderBy(v => v))
{
writer.WriteStartElement("Value");
writer.WriteAttributeString("value", optionValue);
writer.WriteEndElement();
}
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public async Task SendFailedMail(UserOption user, CancellationToken cancellationToken = default)
{
const string subject = "Niet automatisch ingeschreven Fit2Go";
const string content = "Er ging iets mis met het automatisch inschrijven bij Fit2Go.";
await SendMail(user, subject, content, cancellationToken);
}
private static UserOption _UserOption(XElement xuser)
{
var option = new UserOption();
var xoptions = xuser.Elements("Option");
foreach (var xoption in xoptions)
{
var attribute = xoption.Attribute("Name").Value;
var innertext = xoption.Value;
switch (attribute)
{
case "Pass": option.Pass = innertext; break;
case "Group": option.Group = innertext; break;
case "Bypass server userlimit": option.BypassServerUserlimit = innertext; break;
case "User Limit": option.UserLimit = innertext; break;
case "IP Limit": option.IPLimit = innertext; break;
case "Enabled": option.Enabled = innertext; break;
case "Comments": option.Comments = innertext; break;
case "ForceSsl": option.ForceSsl = innertext; break;
}
}
return(option);
}
private async Task ProcessUser(
UserOption user,
DateTimeOffset date,
IEnumerable <DateTimeOffset> lessonTimes,
ILogger log,
CancellationToken cancellationToken = default)
{
var lessonRequest = new GetLessonsRequest(user, date, date.AddDays(1), _options.LocationId);
GetLessonsResponse lessonResponse = await _client.GetLessons(lessonRequest, cancellationToken);
List <Lesson> lessonsToJoin = lessonResponse.Lessons
// Use OrdinalIgnoreCase and keyword "vrij" since the descriptions aren't consistent
.Where(l => l.Description.Contains("vrij", StringComparison.OrdinalIgnoreCase) &&
lessonTimes.Contains(l.LessonStartTime))
.ToList();
if (lessonsToJoin.Count > 0)
{
var success = new List <Lesson>();
var failed = new List <Lesson>();
foreach (Lesson lesson in lessonsToJoin)
{
try
{
var joinRequest = new JoinLessonRequest(user, lesson.Id);
JoinLessonResponse joinResponse = await _client.JoinLesson(joinRequest, cancellationToken);
if (!joinResponse.Warning)
{
success.Add(lesson);
}
else
{
failed.Add(lesson);
}
}
catch (Exception ex)
{
log.LogError(ex, "Something went wrong while joining a lesson. {User} {LessonId}", user.User, lesson.Id);
failed.Add(lesson);
}
}
if (success.Count > 0)
{
var mailRequest = new SendJoinMailRequest(user, success, failed);
await _emailClient.SendJoinMail(mailRequest, cancellationToken);
return;
}
}
else
{
log.LogWarning("LessonsToJoin is empty for {User}", user.User);
}
await _emailClient.SendFailedMail(user);
}
private void FillBoxes()
{
Roles.Items.Add(Role.Admin);
Roles.Items.Add(Role.Owner);
Roles.Items.Add(Role.Employee);
UserOption.GetUsersNames(ref usersList);
}
public void SetUp()
{
fileController = MockRepository.GenerateMock <IFileController>();
fileController.Stub(f => f.DirectoryExists("Folder")).Return(true);
fileController.Stub(f => f.CanCreateFilesIn("Folder")).Return(true);
userOption = new UserOption("var", "Gen", typeof(string), "test-text", "test-description", new string[0], "dv-body", typeof(bool), "validator body", "return true;", true);
}
private async Task SendMail(UserOption user, string subject, string content, CancellationToken cancellationToken = default)
{
EmailAddress from = CreateFromEmail();
EmailAddress to = CreateToEmail(user);
SendGridMessage message = MailHelper.CreateSingleEmail(from, to, subject, content, string.Empty);
await _client.SendEmailAsync(message, cancellationToken);
}
private void ChangeUser_Click(object sender, RoutedEventArgs e)
{
selectedUser.UserName = UserNameTextBox.Text;
selectedUser.Password = UserPasswordTextBox.Text;
selectedUser.UserRole = (Role)Roles.SelectedValue;
UserOption.updateUser(ref selectedUser);
MessageBox.Show("Готово!");
}
public Backer FindBackerByLoginDetails(UserOption backerOption)
{
return(db.Backers
.Where(b => b.Username == backerOption.Username)
.Where(b => b.Password == backerOption.Password)
.Where(b => b.Role == backerOption.Role)
.FirstOrDefault());
}
public ProjectCreator FindProjectCreatorByLoginDetails(UserOption projCreatOption)
{
return(db.ProjectCreators
.Where(pc => pc.Username == projCreatOption.Username)
.Where(pc => pc.Password == projCreatOption.Password)
.Where(pc => pc.Role == projCreatOption.Role)
.FirstOrDefault());
}
/// <summary>
/// ذخیره تنظیمات وب کاربر
/// </summary>
/// <param name="userid">شناسه کاربر</param>
/// <param name="tadbirWebOption">شناسه تنظیمات</param>
/// <param name="webOptionValue"></param>
/// <param name="samanString">اگر لازم است تبدیل کدپیج روی مقدار انجام شد این پارامتر را true ارسال میکنیم</param>
/// <returns></returns>
public bool SetUserOptionValue(int userId, UserOPT userOPT, string optionValue, bool samanString)
{
try
{
UserOption userOption = _dbContext.UserOptions.FirstOrDefault(op => op.UserId == userId && op.Id == (int)userOPT);
if (userOption != null)
{
_dbContext.UserOptions.Remove(userOption);
_dbContext.SaveChanges();
}
userOption = new UserOption()
{
Id = (int)userOPT,
UserId = userId,
OptionValue = optionValue
};
//_dbContext.UserOptions.Add(userOption);
//_dbContext.Database.ExecuteSqlCommand(@"SET IDENTITY_INSERT [dbo].[__UserOption__] ON");
//_dbContext.SaveChanges();
//_dbContext.Database.ExecuteSqlCommand(@"SET IDENTITY_INSERT [dbo].[__UserOption__] OFF");
try
{
var conn = _dbContext.Database.GetDbConnection();
conn.Open();
var command = conn.CreateCommand();
command.CommandText = string.Format("SET IDENTITY_INSERT [dbo].[__UserOption__] ON " +
"INSERT INTO [dbo].[__UserOption__] ([Id], [UserId] ,[OptionValue]) VALUES ({0}, {1}, '{2}') " +
"SET IDENTITY_INSERT[dbo].[__UserOption__] OFF"
, userOption.Id, userOption.UserId, userOption.OptionValue);
command.ExecuteScalar();
conn.Close();
return(true);
}
catch (Exception ex)
{
return(false);
//Debug.WriteLine("File", ex.Message.ToString());
}
//_dbContext.UserOptions.Add(userOption);
//_dbContext.SaveChanges();
//return true;
}
catch (Exception ex)
{
string message = ex.ToString();
return(false);
}
}
internal static void SelectOption()
{
try
{
SqlConnection sqlConnection = DBUtils.GetDBConnection();
sqlConnection.Open();
Console.WriteLine(Writer.connection);
int ID;
Console.WriteLine(Writer.welcome);
Console.WriteLine(Writer.choice);
string choose = Console.ReadLine();
do
{
UserManager userManager = new UserManager();
UserOption userOption = (UserOption)Enum.Parse(typeof(UserOption), choose); //usage enum values
switch (userOption)
{
case UserOption.Registration: //A case to work in options
userManager.RegisterDetail(sqlConnection);
break;
case UserOption.Login:
ID = userManager.Login();
Console.WriteLine(ID);
string role = userManager.GetRole(ID);
Console.WriteLine(role);
if (role == "Admin")
{
BindAdminOption();
}
else
{
BindUserOption();
}
break;
case UserOption.Exit:
System.Environment.Exit(0);
break;
default:
break;
}
Console.WriteLine(Writer.choice);
choose = Console.ReadLine();
} while (true);
}
catch (FormatException msg) //A common catch block for exception
{
Console.WriteLine(msg.Message);
}
catch (Exception msg) //A common catch block for exception
{
Console.WriteLine(msg.Message);
}
}
public void GetOptionLines()
{
//Arrange
System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
UserOption userOption = new UserOption();
//Act
List <string> optionLines = userOption.GetOptionLines().ToList();
//Assert (test default user options)
Assert.Equal("LineTypeSolid solid", optionLines[0]);
Assert.Equal("LineTypeDashed dashed", optionLines[1]);
Assert.Equal("GraphicsFont Helvetica", optionLines[2]);
Assert.Equal("FontStyle plain", optionLines[3]);
Assert.Equal("GraphicsTextColour Black", optionLines[4]);
Assert.Equal("ColourFill blue", optionLines[5]);
Assert.Equal("BWFill gray", optionLines[6]);
Assert.Equal("CategoryBarFill ivory", optionLines[7]);
Assert.Equal("ColourLine red", optionLines[8]);
Assert.Equal("BWLine black", optionLines[9]);
Assert.Equal("LegendTextColour white", optionLines[10]);
Assert.Equal("LegendPosition Default", optionLines[11]);
Assert.Equal("PaletteSet Set1", optionLines[12]);
Assert.Equal("OutputData N", optionLines[13]);
Assert.Equal("OutputAnalysisOptions N", optionLines[14]);
Assert.Equal("OutputPlotsInBW N", optionLines[15]);
Assert.Equal("GeometryDisplay N", optionLines[16]);
Assert.Equal("DisplayModelCoefficients N", optionLines[17]);
Assert.Equal("CovariateRegressionCoefficients N", optionLines[18]);
Assert.Equal("AssessCovariateInteractions N", optionLines[19]);
Assert.Equal("DisplayLSMeansLines N", optionLines[20]);
Assert.Equal("DisplaySEMLines N", optionLines[21]);
Assert.Equal("DisplayPointLabels N", optionLines[22]);
Assert.Equal("TitleSize 20", optionLines[23]);
Assert.Equal("XAxisTitleFontSize 15", optionLines[24]);
Assert.Equal("YAxisTitleFontSize 15", optionLines[25]);
Assert.Equal("XLabelsFontSize 15", optionLines[26]);
Assert.Equal("YLabelsFontSize 15", optionLines[27]);
Assert.Equal("GraphicsXAngle 0", optionLines[28]);
Assert.Equal("GraphicsXHorizontalJust 0.5", optionLines[29]);
Assert.Equal("GraphicsYAngle 0", optionLines[30]);
Assert.Equal("GraphicsYVerticalJust 0.5", optionLines[31]);
Assert.Equal("PointSize 4", optionLines[32]);
Assert.Equal("PointShape 21", optionLines[33]);
Assert.Equal("LineSize 1", optionLines[34]);
Assert.Equal("LegendTextSize 15", optionLines[35]);
Assert.Equal("JpegWidth 6", optionLines[36]);
Assert.Equal("JpegHeight 6", optionLines[37]);
Assert.Equal("PlotResolution 300", optionLines[38]);
Assert.Equal("GraphicsBWLow 0.1", optionLines[39]);
Assert.Equal("GraphicsBWHigh 0.8", optionLines[40]);
Assert.Equal("GraphicsWidthJitter 0.1", optionLines[41]);
Assert.Equal("GraphicsHeightJitter 0.1", optionLines[42]);
Assert.Equal("ErrorBarWidth 0.7", optionLines[43]);
Assert.Equal("FillTransparency 1", optionLines[44]);
}
private bool QuitApplication(UserOption userSelectedOption)
{
if (userSelectedOption != UserOption.Quit)
{
return(false);
}
_display.Quit();
return(true);
}
//------------
//User Options
//------------
public async Task <UserOption> AddUserOption(User user, UserOption option)
{
option.UserId = user.UserId;
var userOption = _context.UsersOptions.Add(option);
await _context.SaveChangesAsync();
return(_context.UsersOptions.FirstOrDefault(o => o.UserOptionsId == option.UserOptionsId));
}
public static UserOption Option(Models.WebUserOption entity)
{
var opt = new UserOption();
opt.Description = entity.WebOption.WebOptionDescription;
opt.ID = entity.WebOptionID.Value;
opt.OptionValue = entity.WebOptionValue;
opt.UserOptionID = entity.ID;
return(opt);
}
public UserOptionTO(UserOption mdo)
{
this.number = mdo.Number;
this.id = mdo.Id;
this.name = mdo.Name;
this.displayName = mdo.DisplayName;
this.key = mdo.Key;
this.reverseKey = mdo.ReverseKey;
this.type = mdo.Type;
this.primaryOption = mdo.PrimaryOption;
}
private void DisplayValidationFunctionFor(UserOption option)
{
currentFunctionScreen.CurrentFunction = option.GetValidatorFunction();
currentFunctionScreen.AllowOverride = true;
currentFunctionScreen.OverrideFunctionChecked = option.IsValidationFunctionOverridden();
currentFunctionScreen.Visible = true;
currentFunctionScreen.Populate();
currentUserOption = option;
currentFunctionType = FunctionTypes.Validation;
}
private void DisplayDefaultValueFunctionFor(UserOption option)
{
currentFunctionScreen.CurrentFunction = option.GetDefaultValueFunction();
currentFunctionScreen.AllowOverride = true;
currentFunctionScreen.OverrideFunctionChecked = option.IsDefaultValueFunctionOverridden();
currentFunctionScreen.Visible = true;
currentFunctionScreen.Populate();
currentUserOption = option;
currentFunctionType = FunctionTypes.DefaultValue;
}
