public Slot Register(Item item)
{
if (IsRegistered(item))
{
this.Log($"Cannot register {item}: Already registered");
return(GetSlot(item));
}
if (!CanRemoveSlot() && IsFull)
{
this.Log($"Cannot register {item}: No free slot available");
return(null);
}
this.Log($"Registering {item}");
var slot = new Slot(item);
if (!IsFull)
{
Slots.Add(slot);
Registered?.Invoke(this, new RegisteredEventArgs(item));
return(slot);
}
Unregister(FirstRemovableSlot.Item);
Slots.Add(slot);
Registered?.Invoke(this, new RegisteredEventArgs(item));
return(slot);
}
public Personne(Name unNom, Registered unRegistered, ID unid, string unphone)
{
this.name = unNom;
this.registered = unRegistered;
this.id = unid;
this.phone = unphone;
}
public IHttpActionResult IsAuthorized(Registered player)
{
if (player == null)
{
return(BadRequest());
}
// check if there is an active session
var sessionPlayer = _userSessionUserRepository.GetUserSession();
if (sessionPlayer != null)
{
return(Ok(sessionPlayer));
}
// if User is authenticated succeccfully data is saved in session and response code 200 is returned
var currentPlayer = _playerBusinessModel.UserExists(player.Name, player.Password);
if (currentPlayer != null)
{
_userSessionUserRepository.SetUserSession(currentPlayer);
return(Ok(currentPlayer));
}
return(BadRequest());
}
private void ValidateLogin(Registered person, Registered repositoryPerson)
{
if (person == null)
{
return;
}
if (repositoryPerson == null)
{
ModelState.AddModelError(nameof(Registered.NickName), "This nickname doesn't exist!");
return;
}
if (!person.NickName.Equals(repositoryPerson.NickName))
{
ModelState.AddModelError(nameof(Registered.NickName), "This nickname doesn't exist!2");
}
if (person.Password == null)
{
ModelState.AddModelError(nameof(Registered.Password), "No password?");
return;
}
if (!person.Password.Equals(repositoryPerson.Password))
{
ModelState.AddModelError(nameof(Registered.Password), "Password incorrect");
}
}
public async Task DeleteAsync(Registered parameters)
{
var register = Uow.Repository <Registered>().FindByKey(parameters.Id);
await Uow.RegisterDeletedAsync(register);
await Uow.CommitAsync();
}
public IQuery Registered(PrimitiveEvent primitiveEvent, Registered registered)
{
return(RawQuery.Create(@"
if exists
(
select null from Argument where Id = @Id
)
update
Argument
set
Name = @Name,
DataTypeName = @DataTypeName
where
Id = @Id
else
insert into Argument
(
Id,
Name,
DataTypeName
)
values
(
@Id,
@Name,
@DataTypeName
)
")
.AddParameterValue(Columns.Id, primitiveEvent.Id)
.AddParameterValue(Columns.Name, registered.Name)
.AddParameterValue(Columns.DataTypeName, registered.DataTypeName));
}
public ActionResult Registered(Registered newData)
{
ViewBag.userId = newData.userId;
ViewBag.userPassword = newData.userPassword;
if (string.IsNullOrEmpty(newData.userId) ||
string.IsNullOrEmpty(newData.userPassword.ToString())
)
{
return(View());
}
SqlConnection cn = new SqlConnection(@"server=.\SQLExpress_2;database=collectBooksManageList;Integrated Security=true");
SqlCommand cmd = new SqlCommand("select * from Registered where userId=@id", cn);
cmd.Parameters.AddWithValue("@id", newData.userId);
cn.Open();
int num = Convert.ToInt32(cmd.ExecuteScalar());
cn.Close();
if (num == 0)
{
db.Registereds.Add(newData);
db.SaveChanges();
return(RedirectToAction("Login"));
}
else
{
ViewBag.show = "ID重複";
return(View());
}
}
public Registered getByNickname(String nickName)
{
DbCommand query = connection.CreateCommand();
query.CommandText = "SELECT * FROM Person where nickName = @nickName;";
query.Parameters.Add(MakeDbParameter(query, "nickName", DbType.String, nickName));
if (connection.State == ConnectionState.Open)
{
Registered person = null;
using (DbDataReader dbDataReader = query.ExecuteReader())
{
if (dbDataReader.Read())
{
person = new Registered(
Convert.ToString(dbDataReader["nickName"]),
Convert.ToString(dbDataReader["password"]),
Convert.ToString(dbDataReader["firstName"]),
Convert.ToString(dbDataReader["lastName"]),
(EPerson)Convert.ToInt32(dbDataReader["accessLevel"])
);
}
}
return(person);
}
else
{
throw new Exception("Database: Connection is not opened");
}
}
/// <summary>
/// Triggers the <see cref="Registered"/> event
/// </summary>
protected void TriggerRegisteredEvent(IPeer peer, IAccountData account)
{
if (Registered != null)
{
Registered.Invoke(peer, account);
}
}
public static Registered validateUser(string userName, string passWord)
{
Registered isRegister = null;
using (SqlConnection conn = new SqlConnection(connectionString))
{
try
{
conn.Open();
string sql = "SELECT TOP 1 * FROM registered_respondents WHERE username ='******' AND password = '******'";
SqlCommand cmd = new SqlCommand(sql, conn);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
isRegister = new Registered();
isRegister.Username = reader["username"].ToString();
isRegister.Password = reader["password"].ToString();
isRegister.First_Name = reader["First_Name"].ToString();
isRegister.RegisteredID = (int)reader["RespondentID"];
}
}
catch (SqlException ex)
{
System.Diagnostics.Debug.WriteLine("Connection Error: " + ex.Message);
}
finally
{
conn.Close();
}
}
return(isRegister);
}
public async Task <bool> TryRegister(string pass, string login)
{
await allDbContext.Clients.LoadAsync();
if (await allDbContext.Clients.FirstOrDefaultAsync(x => x.Password == pass) != null)
{
ErrorMessage = "Такой пароль уже есть";
return(false);
}
_client = new Client {
Login = login, Email = Email, Name = _name, Password = pass
};
allDbContext.Clients.Add(_client);
try
{
await allDbContext.SaveChangesAsync();
Registered?.Invoke();
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
return(false);
}
return(true);
}
public void RegisterTest()
{
shutdownAll();
string value = null;
var pid = spawn <string>("reg-proc", msg => value = msg);
var regid = reg("woooo amazing", pid);
Assert.IsTrue(Registered.Count() == 1);
Assert.IsTrue(Registered.First().Value == "/root/system/registered/woooo amazing");
tell(regid, "hello");
Thread.Sleep(100);
Assert.IsTrue(value == "hello");
Thread.Sleep(100);
unreg("woooo amazing");
Thread.Sleep(100);
Assert.IsTrue(Registered.Count() == 0);
}
public List <Registered> GetAll()
{
DbCommand query = connection.CreateCommand();
query.CommandText = "SELECT * FROM Person order by id";
if (connection.State == ConnectionState.Open)
{
List <Registered> people = new List <Registered>();
using (DbDataReader dbDataReader = query.ExecuteReader())
{
Registered person;
while (dbDataReader.Read())
{
person = null;
person = new Registered(
Convert.ToString(dbDataReader["nickName"]),
Convert.ToString(dbDataReader["password"]),
Convert.ToString(dbDataReader["firstName"]),
Convert.ToString(dbDataReader["lastName"]),
(EPerson)Convert.ToInt32(dbDataReader["accessLevel"])
);
people.Add(person);
}
}
if (people.Count <= 0)
{
return(null);
}
return(people);
}
else
{
throw new Exception("Database: Connection is not opened");
}
}
private void OnEnable()
{
foreach (IManagedObject managedObject in GetComponents <IManagedObject>())
{
Registered?.Invoke(managedObject);
}
}
private void DisplayContent(API.Data.Project project)
{
Title = project.Title;
Registered myproj = Array.Find <Registered> (project.Registered, x => x.Code == project.UserProjectCode);
List <Registered> registeredStudent = new List <Registered> (project.Registered);
registeredStudent.Remove(myproj);
registeredStudent.Insert(0, myproj);
if (!(registeredStudent.Count == 1 && registeredStudent [0] == null))
{
ListView listView = new ListView {
ItemTemplate = new DataTemplate(typeof(ProjectGroupCell)),
Header = new FilesHeader(this, project),
ItemsSource = registeredStudent,
HasUnevenRows = true,
VerticalOptions = LayoutOptions.FillAndExpand
};
listView.ItemSelected += (sender, e) => {
if (e.SelectedItem != null)
{
listView.SelectedItem = null;
}
};
Content = listView;
}
else
{
Content = new FilesHeader(this, project);
}
}
protected void BtnLogIn_Click(object sender, EventArgs e)
{
string userName = txtUserName.Text;
string passWord = txtPassword.Text;
Registered validateUser = DbUtlities.validateUser(userName, passWord);
if (DbUtlities.validateStaffLogin(userName, passWord))
{
FormsAuthentication.RedirectFromLoginPage(userName, false);
Response.Cookies["adminLogin"].Value = "Admin Logged in";
Session["registeredName"] = userName;
Session["adminisLoggedIn"] = true;
}
else if (validateUser != null)
{
FormsAuthentication.RedirectFromLoginPage(userName, false);
Response.Cookies["userLogin"].Value = "User Logged in";
//Session["registeredUser"] = validateUser.Username;
Session["registeredName"] = validateUser.Username;
Session["RegisteredID"] = validateUser.RegisteredID;
Session["userisLoggedIn"] = true;
Response.Redirect("Default.aspx");
}
else
{
Msg.Text = "Invalid User";
}
}
public static async Task RegisteredType_AdditionalLink(
Guid id,
Guid parentId,
UnequalNonNullPair <NonEmptyString> routes,
JsonSerializerSettings serializerSettings)
{
if (serializerSettings is null)
{
throw new ArgumentNullException(nameof(serializerSettings));
}
var dto = new Registered
{
Id = id,
ParentId = parentId,
};
var(route, parentRoute) = routes;
var builder = new TransformationMap.Builder <Registered>(r => Const(new Uri($"https://example.invalid/registered/{r.Id}")));
ITransformationMap <Registered> transformationMap = builder;
_ = transformationMap.Link("up", r => Const(new Uri($"https://example.invalid/parent/{r.ParentId}")));
var map = new Dictionary <Type, ITransformationInstructions>
{
[typeof(Registered)] = builder,
};
await using var serviceProvider = new ServiceCollection()
.AddScoped <ILinkBuilder <Constant>, LinkBuilder.Constant>()
.BuildServiceProvider();
var repo = new HalRepository(map, serviceProvider);
serializerSettings.Converters.Add(new LinkCollection.Converter());
var sut = new HalJsonOutputFormatter(serializerSettings, ArrayPool <char> .Shared, new MvcOptions(), repo);
using var writer = new StringWriter();
var context = new OutputFormatterWriteContext(
new DefaultHttpContext(),
(_, _) => writer,
typeof(Registered),
dto);
await sut.WriteResponseBodyAsync(context, new UTF8Encoding(encoderShouldEmitUTF8Identifier : false)).ConfigureAwait(false);
var actual = JsonConvert.DeserializeObject <HollowHal>(writer.ToString(), serializerSettings);
Assert.NotNull(actual);
Assert.Empty(actual.Embedded);
Assert.NotNull(actual.Links);
Assert.Equal(2, actual.Links.Count);
var self = Assert.Contains("self", actual.Links);
Assert.NotNull(self);
Assert.Equal($"https://example.invalid/registered/{id}", self.Href);
var parent = Assert.Contains("up", actual.Links);
Assert.NotNull(parent);
Assert.Equal($"https://example.invalid/parent/{parentId}", parent.Href);
}
public ActionResult DeleteConfirmed(int sectionid, int studentid)
{
Registered registered = db.Registereds.Find(studentid, sectionid);
db.Registereds.Remove(registered);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public override string ToString()
{
return("user[" + ID + "] Name: " + Name + Environment.NewLine +
"user[" + ID + "] Online: " + Online + Environment.NewLine +
"user[" + ID + "] Socket: " + Socket + Environment.NewLine +
"user[" + ID + "] LastOnline: " + LastOnline.ToString("yyyy-MM-dd HH:mm:ss") + Environment.NewLine +
"user[" + ID + "] Registered: " + Registered.ToString("yyyy-MM-dd HH:mm:ss"));
}
public IHttpActionResult NameAvailable(Registered player)
{
if (_playerBusinessModel.UserExists(player?.Name))
{
return(Ok(false));
}
return(Ok(true));
}
private Registered On(Registered registered)
{
Guard.AgainstNull(registered, nameof(registered));
Name = registered.Name;
return(registered);
}
private Registered On(Registered registered)
{
Guard.AgainstNull(registered, nameof(registered));
_username = registered.Username;
_passwordHash = registered.PasswordHash;
return(registered);
}
static async Task OnRegisteredSuccess(NSData token)
{
byte[] result = new byte[token.Length];
Marshal.Copy(token.Bytes, result, 0, (int)token.Length);
var cleanToken = BitConverter.ToString(result).Replace("-", "");
await Registered.RaiseOn(Thread.Pool, cleanToken);
SetUserDefault(cleanToken);
}
private void Add <TFieldProperties>(FactoryFunction fieldFactory)
{
Guard.NotNull(fieldFactory, nameof(fieldFactory));
typeNameRegistry.Map(typeof(TFieldProperties));
var registered = new Registered(fieldFactory, typeof(TFieldProperties));
fieldsByPropertyType[registered.PropertiesType] = registered;
}
public void AddPlayerToTable(Table table, Registered player)
{
using (var context = new XoContext())
{
context.Entry(table).State = EntityState.Modified;
var p = context.Players.OfType <Registered>().FirstOrDefault(x => x.Id == player.Id);
table.Players.Add(p);
context.SaveChanges();
}
}
public async Task <ActionResult> ConfirmCancelRegistration(int id)
{
Registered RegistrationToDelete = await db.Registered.FirstOrDefaultAsync(a => a.SessionDelegateId == id);
db.Registered.Remove(RegistrationToDelete);
await db.SaveChangesAsync();
TempData["Success"] = "1 Delegate Registration Successfully Cancelled";
return(RedirectToAction("Index"));
}
public ActionResult Register(LoginViewModel userModel)
{
try
{
using (ReportScheduleEntities db = new ReportScheduleEntities())
{
if ((userModel.user_new_login == null) || (userModel.user_new_password.Trim() == "") || (userModel.user_confirm_password.Trim() == "") || (userModel.user_email.Trim() == ""))
{
ViewBag.Action = "Register";
return(View("Index", userModel));
}
if (CheckUserLogin(userModel.user_new_login.Trim(), userModel.user_id))
{
userModel.LoginErrorMessage = "Такой логин уже существует!";
ViewBag.Action = "Register";
return(View("Index", userModel));
}
if (CheckUserEmail(userModel.user_email.Trim(), userModel.user_id))
{
userModel.LoginErrorMessage = "Такой email уже существует!";
ViewBag.Action = "Register";
return(View("Index", userModel));
}
string pass = encryption(userModel.user_new_password);
Guid guid = Guid.NewGuid();
Registered reg = new Registered()
{
reg_email = userModel.user_email.Trim(),
reg_login = userModel.user_new_login.Trim(),
reg_surname = userModel.user_surname,
reg_name = userModel.user_name,
reg_patronymic = userModel.user_patronymic,
reg_password = pass,
reg_guid = guid
};
SendMail(reg.reg_email, guid.ToString());
db.Registered.Add(reg);
db.SaveChanges();
ViewBag.Action = "Registered";
return(View("Index", userModel));
}
}
catch (Exception ex)
{
throw ex;
}
}
private void Add(T instance)
{
if (Filter != null && !Filter(instance))
{
return;
}
_space.Add(instance);
_newInstances.Add(instance);
Registered?.Invoke(instance);
}
public Registered On(Registered registered)
{
Guard.AgainstNull(registered, "registered");
_username = registered.Username;
_passwordHash = registered.PasswordHash;
_registeredBy = registered.RegisteredBy;
_dateRegistered = registered.DateRegistered;
return(registered);
}
public void Can_Take_Order_All_Field_Is_Test()
{
//Arrange
Registered user = UsersReg.Users[0];
user.AddProductToCart(Store.Products[0].Name, 1);
//Act
user.CreateNewOrder("Test", "Test", "Test", true);
//Assert
Assert.Single(user.Orders);
}
public void UnityResolveSingleInstance()
{
var container = new UnityContainer();
var registered = new Registered();
container.RegisterInstance(registered);
var resolver = new UnityDependencyResolver(container);
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void WindsorResolveSingleInstance()
{
var container = new WindsorContainer();
var registered = new Registered();
container.Register(Component.For<Registered>().Instance(registered));
var resolver = new WindsorDependencyResolver(container);
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void AutofacResolveSingleInstance()
{
var builder = new ContainerBuilder();
var registered = new Registered();
builder.RegisterInstance(registered);
var resolver = new AutofacDependencyResolver(builder.Build());
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void NinjectResolveSingleInstance()
{
var kernel = new StandardKernel();
var registered = new Registered();
kernel.Bind<Registered>().ToConstant(registered);
var resolver = new NinjectDependencyResolver(kernel);
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void StructureMapResolveSingleInstance()
{
var registered = new Registered();
ObjectFactory.Initialize(i => i.Register(registered));
var resolver = new StructureMapDependencyResolver(ObjectFactory.Container);
var resolved = (Registered) resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
public void SimpleInjectorResolveSingleInstance()
{
var container = new global::SimpleInjector.Container();
var registered = new Registered();
container.RegisterSingle(typeof(Registered), registered);
var resolver = new SimpleInjectorDependencyResolver(container);
var resolved = resolver.GetInstance(typeof (Registered));
Assert.That(resolved, Is.EqualTo(registered));
}
