public ParameterListViewModel(INavigation navigation)
{
_navigation = navigation;
_parameterRepository = new ParameterRepository();
EditParameterCommand = new Command(async() => await EditParameter());
FetchParameters();
}
public static ParameterEntity FindByUserParamaterId(int id)
{
UserParameter userParameter = UserParameterRepository.FindById(id);
Parameter parameter = ParameterRepository.FindById(userParameter.Id);
return(new ParameterEntity(parameter, userParameter));
}
public void SendRecoverPasswordNotification(string email, string recoveredPassword)
{
var userRepository = new UserRepository(_context);
var user = userRepository.GetByEmail(email);
var parameterRepository = new ParameterRepository(_context);
var body = Resource.PasswordRecoveryEmailBody
.Replace("{username}", user.Name)
.Replace("{login}", email)
.Replace("{password}", recoveredPassword)
.Replace("{link}", Parameter.BASE_URL);
var message = new MailMessage();
message.To.Add(email);
message.From = new MailAddress(parameterRepository.GetValueByKey(Parameter.EMAIL_FROM_KEY),
Parameter.APP_NAME);
message.Subject = Resource.PasswordRecoveryEmailSubject;
message.IsBodyHtml = true;
message.Body = body;
_sender.Send(message);
}
private void btnInsert_Click(object sender, EventArgs e)
{
try
{
if (tbxName.Text != "" && tbxUnit.Text != "")
{
ParameterRepository pr = new ParameterRepository();
bool response = pr.InsertParameter(DeviceID, tbxName.Text, tbxUnit.Text, tbxParameterDesc.Text);
if (response)
{
MessageBox.Show("اطلاعات با موفقیت ثبت شد.");
DisplayData();
ClearData();
}
}
else
{
MessageBox.Show("خطادر ثبت اطلاعات!");
}
}
catch
{
MessageBox.Show("خطادر ثبت اطلاعات!");
}
}
public static ParameterEntity FindByParameterName(string name)
{
Parameter parameter = ParameterRepository.FindByName(name);
UserParameter userParameter = UserParameterRepository.FindByParameterId(parameter.Id);
return(new ParameterEntity(parameter, userParameter));
}
public void TestInitailize()
{
parametersDbSet = new TestDbSet <Parameter>()
{
new Parameter()
{
ParameterId = 0,
ParameterName = "@test",
ParameterRuName = "test",
ParameterType = "text",
ParameterCreatedDate = DateTime.Now
},
new Parameter()
{
ParameterId = 1,
ParameterName = "@another_one",
ParameterRuName = "another_one",
ParameterType = "number",
ParameterCreatedDate = DateTime.Now
}
};
mock = new Mock <IContext>();
mock
.Setup(p => p.Parameters)
.Returns(parametersDbSet);
repository = new ParameterRepository(mock.Object);
}
internal void SendCreatingUserNotiication(User user, string password)
{
var parameterRepository = new ParameterRepository(_context);
var body = Resource.CreatingUserNotificationEmailBody
.Replace("{username}", user.Name)
.Replace("{login}", user.Login)
.Replace("{password}", password)
.Replace("{link}", Parameter.BASE_URL);
var message = new MailMessage();
message.To.Add(user.Email);
message.From = new MailAddress(parameterRepository.GetValueByKey(Parameter.EMAIL_FROM_KEY),
Parameter.APP_NAME);
message.Subject = Resource.CreatingUserNotificationEmailSubject;
message.IsBodyHtml = true;
message.Body = body;
//var client = new SmtpClient(parameterRepository.GetValueByKey(Parameter.SMTP_SERVER_KEY), System.Convert.ToInt32(parameterRepository.GetValueByKey(Parameter.SMTP_PORT_KEY)))
//{
// Credentials = new NetworkCredential(parameterRepository.GetValueByKey(Parameter.EMAIL_FROM_KEY), parameterRepository.GetValueByKey(Parameter.SMTP_PASSWORD_KEY)),
// EnableSsl = true
//};
//client.Send(parameterRepository.GetValueByKey(Parameter.EMAIL_FROM_KEY), user.Email, Resource.CreatingUserNotificationEmailSubject, body);
_sender.Send(message);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var parameterID = -1;
var visible = Visibility.Collapsed;
if (value != null && Int32.TryParse(value.ToString(), out parameterID) && parameterID > 0)
{
var valueType = ParameterRepository.GetParameterValueType(parameterID);
switch ((string)parameter)
{
case "Number":
visible = (valueType == EParameterValueType.Int32 || valueType == EParameterValueType.Decimal) ? Visibility.Visible : Visibility.Collapsed;
break;
case "String":
visible = (valueType == EParameterValueType.String) ? Visibility.Visible : Visibility.Collapsed;
break;
case "DateTime":
visible = (valueType == EParameterValueType.DateTIme) ? Visibility.Visible : Visibility.Collapsed;
break;
case "Path":
visible = (valueType == EParameterValueType.Path) ? Visibility.Visible : Visibility.Collapsed;
break;
case "Enum":
visible = (valueType == EParameterValueType.Enum) ? Visibility.Visible : Visibility.Collapsed;
break;
}
;
}
;
return(visible);
}
public List <Service> GetPublicServices([FromUri] int?UserWorkId)
{
//Hours to public Serive
String _hoursToPublicService = ParameterRepository.findByCode("hours_To_Public_Service");
int hoursToPublicService = (int)Int32.Parse(_hoursToPublicService);
DateTime dateToCompare = DateTime.Now.AddHours(-1 * hoursToPublicService);
//Service Provider Speed
String _PublicServiceUserSpeed = ParameterRepository.findByCode("Public_Service_User_Speed");
double PublicServiceUserSpeed = Double.Parse(_PublicServiceUserSpeed);
//Avg Service In a day
String _PublicServiceUserAvg = ParameterRepository.findByCode("Public_Service_User_Avg_Services");
double PublicServiceUserAvg = Double.Parse(_PublicServiceUserAvg);
List <Service> services = db.Services.Where(a => a.Status.Equals("Active") &&
a.ServiceProviderNewDate.CompareTo(dateToCompare) <= 0)
.Include("Comments")
.Include("UserWork")
.Include("ServiceProvider")
.Include("Creator")
.OrderByDescending(a => a.CreationDate)
.ToList();
if (UserWorkId != null)
{
services = services.Where(a => a.UserWorkId.Equals(UserWorkId)).ToList();
}
return(services);
}
public void SendEmail(User[] recipients, string senderName, string subject, string messageBody)
{
var mailMessage = new MimeMessage();
ParameterRepository parameterRepository = new ParameterRepository();
string smtpEmail = parameterRepository.FindParameterValueByName("SMTP_EMAIL");
string smtpHost = parameterRepository.FindParameterValueByName("SMTP_HOST");
int smtpPort = Convert.ToInt32(parameterRepository.FindParameterValueByName("SMTP_PORT"));
string smtpPassword = parameterRepository.FindParameterValueByName("SMTP_PASSWORD");
mailMessage.From.Add(new MailboxAddress(senderName, smtpEmail));
foreach (User recipient in recipients)
{
mailMessage.To.Add(
new MailboxAddress(
$"{recipient.FirstName} {recipient.LastName}",
recipient.Email)
);
}
mailMessage.Subject = subject;
mailMessage.Body = new TextPart("plan")
{
Text = messageBody
};
using (var client = new SmtpClient())
{
client.Connect(smtpHost, smtpPort, true);
client.Authenticate(smtpEmail, smtpPassword);
client.Send(mailMessage);
client.Disconnect(true);
}
}
public static void LoadParameters(IContext context)
{
var parameterRepository = new ParameterRepository(context);
APP_NAME = parameterRepository.GetValueByKey(APP_NAME_KEY);
FILE_STORAGE = parameterRepository.GetValueByKey(FILE_STORAGE_KEY);
DAEMON_USER = parameterRepository.GetValueByKey(DAEMON_USER_KEY);
BASE_URL = parameterRepository.GetValueByKey(BASE_URL_KEY);
}
public AuthenticationService(IContext context, IMailSender sender)
{
_context = context;
_notificationService = new NotificationService(_context, sender);
_crypt = new SymmetricCrypt(SymmetricCryptProvider.TripleDES);
var parameterRepository = new ParameterRepository(_context);
_crypt.Key = parameterRepository.GetValueByKey(Parameter.CRYPTO_KEY);
}
public ParameterRepoTest()
{
_serviceProvider = new ServiceCollection()
.AddTransient <ParameterRepository>()
.AddDbContext <ApplicationContext>(options => options.UseInMemoryDatabase(Guid.NewGuid().ToString()), ServiceLifetime.Transient)
.BuildServiceProvider();
_sut = _serviceProvider.GetService <ParameterRepository>();
_context = _serviceProvider.GetService <ApplicationContext>();
}
public void FindParametersByNameOrderedByCreatedDescMethodTest()
{
// Arrange
TestDbSet <Parameter> parametersDbSet = new TestDbSet <Parameter>()
{
new Parameter()
{
ParameterId = 0,
ParameterName = "first parameter name",
ParameterRuName = "nevermind",
ParameterType = "text",
ParameterCreatedDate = DateTime.Today
},
new Parameter()
{
ParameterId = 1,
ParameterName = "second parameter",
ParameterRuName = "same",
ParameterType = "phone",
ParameterCreatedDate = DateTime.Today.AddDays(-1)
},
new Parameter()
{
ParameterId = 2,
ParameterName = "third parameter name",
ParameterRuName = "unclear",
ParameterType = "number",
ParameterCreatedDate = DateTime.Today.AddDays(-2)
}
};
var mock = new Mock <IContext>();
mock
.Setup(x => x.Parameters)
.Returns(parametersDbSet);
ParameterRepository repository = new ParameterRepository(mock.Object);
// Act
IEnumerable <Parameter> parameters = repository.FindParametersByNameOrderedByCreatedDesc("name");
int[] expectedParameterIds = new int[] { 0, 2 };
// Assert
Assert.AreEqual(2, parameters.Count());
Assert.IsFalse(expectedParameterIds.Contains(1));
Assert.IsTrue(parameters.First().ParameterCreatedDate > parameters.Last().ParameterCreatedDate);
foreach (Parameter param in parameters)
{
Assert.IsTrue(param.ParameterName.Contains("name"));
Assert.IsTrue(expectedParameterIds.Contains(param.ParameterId));
}
}
public void GetParameters_Success_ReturnEntities()
{
// Arrange
var repository = new ParameterRepository();
// Act
var result = repository.GetParameters();
// Assert
Assert.IsInstanceOf <IEnumerable <Parameter> >(result);
}
public void Get_Fail_ReturnNull()
{
// Arrange
var repository = new ParameterRepository();
// Act
var result = repository.Get(111_111_111);
// Assert
Assert.IsNull(result);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
string name = String.Empty;
int parameterID = -1;
if (Int32.TryParse(value.ToString(), out parameterID) && parameterID > 0)
{
name = ParameterRepository.GetParameterName(parameterID);
}
;
return(name);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var list = new List <ParameterValue>();
var parameterID = -1;
if (value != null && Int32.TryParse(value.ToString(), out parameterID) && parameterID > 0)
{
list = ParameterRepository.GetParameterValues(parameterID).ToList();
}
;
return(list);
}
public void Update_Success_ReturnFalse()
{
// Arrange
var repository = new ParameterRepository();
var input = GenerateInput(generateId: true);
// Act
var result = repository.Update(input);
// Assert
Assert.IsFalse(result);
}
public void GetParameterByName_Success_ReturnEntity()
{
// Arrange
var repository = new ParameterRepository();
var input = repository.Create(GenerateInput());
// Act
var result = repository.GetParameterByName(input.Key);
// Assert
Assert.That(result != null && result.Key == input.Key);
}
public void Get_Success_ReturnEntity()
{
// Arrange
var repository = new ParameterRepository();
var input = repository.Create(GenerateInput());
// Act
var result = repository.Get(input.Id);
// Assert
Assert.IsInstanceOf <Parameter>(result);
}
public void Create_Success_ReturnEntity()
{
// Arrange
var repository = new ParameterRepository();
var input = GenerateInput();
// Act
var result = repository.Create(input);
// Assert
Assert.That(CompareProperties(input, result));
}
public void Delete_Success_ReturnNull()
{
// Arrange
var repository = new ParameterRepository();
var input = repository.Create(GenerateInput());
// Act
repository.Delete(input.Id);
var result = repository.Get(input.Id);
// Assert
Assert.IsNull(result);
}
public ActionResult Register(int?TestId, string employee_code)
{
// register the user for the Test
Employees employee = db
.Employees
.Include("Registrations")
.FirstOrDefault(emp => emp.EId.Equals(employee_code, StringComparison.InvariantCultureIgnoreCase));
Test test = db.Tests.FirstOrDefault(t => t.Id == TestId);
List <Registration> registrations = db
.Registrations
.Where(reg => reg.TestId == TestId && reg.EmployeeId == employee.Id).ToList();
// If the employee has already registered for the Test --->
var _maxNumberOfAllowedExams = ParameterRepository.findByCode("max_number_of_allowed_exams");
int maxNumberOfAllowedExams = Int32.Parse(_maxNumberOfAllowedExams);
if (registrations.Count() >= maxNumberOfAllowedExams)
{
Session["TOKEN"] = registrations[0].Token;
TempData["errMessage"] = "You can only take the test twice, If you believe that there is something wrong please contact your direct manager";
return(RedirectToAction("InstructionPage", new { TestId, employee_code }));
//return RedirectToAction("FinalResult", new { TestId, token = registrations[0].Token });
}
// Create New Registration
else
{
Registration newRegistration = new Registration()
{
EmployeeId = employee.Id,
TestId = TestId.GetValueOrDefault(),
RegistrationDate = DateTime.Now,
ExpiresDate = DateTime.Now.AddMinutes(test.DurationInMinutes),
Token = Guid.NewGuid()
};
employee.Registrations.Add(newRegistration);
db.Registrations.Add(newRegistration);
db.SaveChanges();
Session["TOKEN"] = newRegistration.Token;
Session["ExpireDate"] = newRegistration.ExpiresDate;
Session.Timeout = test.DurationInMinutes;
}
return(RedirectToAction("EvalPage", new { @token = Session["TOKEN"] }));
}
public void Update_Success_ReturnTrue()
{
// Arrange
var repository = new ParameterRepository();
var input = repository.Create(GenerateInput());
var inputForUpdate = GenerateInput(id: input.Id);
// Act
var result = repository.Update(inputForUpdate);
// Assert
Assert.IsTrue(result);
}
public Controller()
{
#region Create mapper
MapperConfiguration config = new MapperConfiguration(cfg => {
cfg.AddProfile(new MapperProfile());
});
this.Mapper = config.CreateMapper();
#endregion
Parameters = new ParameterRepository(this.Mapper);
var msg = this.Parameters.Add(new Parameter()
{
ParameterName = "left", ParameterValue = 0, ParameterType = new TypeParameter()
{
NameType = "int", Type = typeof(int)
}
});
logger.ShowMessages(normalizer.Normalize(msg));
msg = this.Parameters.Add(new Parameter()
{
ParameterName = "right", ParameterValue = 0, ParameterType = new TypeParameter()
{
NameType = "int", Type = typeof(int)
}
});
logger.ShowMessages(normalizer.Normalize(msg));
msg = this.Parameters.Add(new Parameter()
{
ParameterName = "expr", ParameterValue = 0, ParameterType = new TypeParameter()
{
NameType = "string", Type = typeof(string)
}
});
logger.ShowMessages(normalizer.Normalize(msg));
msg = this.Parameters.Add(new Parameter()
{
ParameterName = "steps", ParameterValue = 0, ParameterType = new TypeParameter()
{
NameType = "double", Type = typeof(double)
}
});
logger.ShowMessages(normalizer.Normalize(msg));
Commands.Add("set", (parameter) => Set(parameter));
Commands.Add("get", (parameter) => Get(parameter));
Commands.Add("monteinit", (parameter) => InitMontecarloMethod(parameter));
Commands.Add("emulate", (parameter) => Emulate(parameter));
}
private void btnDelete_Click(object sender, EventArgs e)
{
ParameterRepository dr = new ParameterRepository();
try
{
dr.DeleteParameter(ParameterID);
MessageBox.Show("حذف با موفقیت انجام شد");
ClearData();
DisplayData();
}
catch
{
MessageBox.Show(" خطا در حذف!");
}
}
public List <ServiceViewModel> GetPublicServicesWithoutFilter()
{
String _hoursToPublicService = ParameterRepository.findByCode("hours_To_Public_Service");
int hoursToPublicService = _hoursToPublicService == null? 24: (int)Int32.Parse(_hoursToPublicService);
DateTime dateToCompare = DateTime.Now.AddHours(-1 * hoursToPublicService);
//Service Provider Speed
String _PublicServiceUserSpeed = ParameterRepository.findByCode("Public_Service_User_Speed");
double PublicServiceUserSpeed = _PublicServiceUserSpeed == null?1.0:Double.Parse(_PublicServiceUserSpeed);
//Avg Service In a day
String _PublicServiceUserAvg = ParameterRepository.findByCode("Public_Service_User_Avg_Services");
double PublicServiceUserAvg = _PublicServiceUserAvg == null?1.0: Double.Parse(_PublicServiceUserAvg);
String userId = core.getCurrentUser().Id;
ApplicationUser user = db.Users.Where(a => a.Id.Equals(userId)).Include("userWorkBinding").FirstOrDefault();
List <int> userWorkIds = new List <int>();
List <Service> services = db.Services.Where(a => a.Status.Equals("Active") &&
a.ServiceProviderNewDate.CompareTo(dateToCompare) <= 0)
.Include("Comments")
.Include("UserWork")
.Include("ServiceProvider")
.Include("Creator")
.OrderByDescending(a => a.CreationDate)
.ToList();
if (user.userWorkBinding.Count > 0)
{
foreach (var item in user.userWorkBinding)
{
userWorkIds.Add(item.UserWorkId);
}
services = services.Where(a => userWorkIds.Contains(a.UserWorkId)).ToList();
}
else
{
services = new List <Service>();
}
List <ServiceViewModel> result = new List <ServiceViewModel>();
foreach (var item in services)
{
result.Add(getMapping(item));
}
return(result.Where(a => a.ServiceProviderAvgServices < PublicServiceUserAvg && a.ServiceProviderSpeed < PublicServiceUserSpeed).ToList());
}
private void SettingsApplyButton_Click(object sender, RoutedEventArgs e)
{
if (checkConnection(true))
{
UserSettings.ConnectionString = ConnectionString.ConnectionString;
UserSettings.StoragePath = StoragePath;
UserSettings.ProfileRole = (ERole)ProfileRole;
Properties.Settings.Default.Save();
if (_dc != null)
{
_dc.SubmitChanges();
}
;
closeWindow();
ParameterRepository.Reload();
this.DialogResult = true;
}
;
}
public ScriptCalculatorTestEngine()
{
var logger = new Mock <ILogger <CalculateCommand.Handler> >();
ScriptInterpreterDbContext = new ScriptInterpreterDbContext(
new DbContextOptions <ScriptInterpreterDbContext>());
ParameterRepository = new ParameterRepository(context: ScriptInterpreterDbContext);
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new ScriptMappingProfile());
});
ScriptRepository = new ScriptRepository(ScriptInterpreterDbContext);
TranslationService = new TranslationService(new TranslationRepository(ScriptInterpreterDbContext));
Mapper = new Mapper(config);
CalculateCommand = new CalculateCommand.Handler(ScriptRepository,
ParameterRepository, TranslationService, Mapper);
}
