Example #1
0
 public CheckIn(BasicUser user, Guid targetId, string title, string content, List <Asset> asset, GeoPoint location) : base(user, targetId, title, content, asset)
 {
     Location   = location;
     EntityType = "CheckIn";
     BlogType   = "CheckIn";
     IsEssence  = false;
 }
Example #2
0
        public static async Task <bool> RemoveFromAllCommitteesAsync(this BasicUser user, AppModelContainer appModel)
        {
            if (user.UserType < UsersTypes.Member)
            {
                return(true);
            }
            try
            {
                var member = user as MemberUser;
                if (member == null)
                {
                    throw new InvalidCastException();
                }

                appModel.Entry(member).State = EntityState.Unchanged;
                var memberOfCommittees = member.MemberOf.ToList();
                foreach (var committee in memberOfCommittees)
                {
                    committee.Members.Remove(member);
                    appModel.Entry(committee).State = EntityState.Modified;
                }
                await appModel.SaveChangesAsync();

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Example #3
0
        public void CanGetRightNumberOfAdmins()
        {
            var user1 = Generator.GenerateUser("user1", "pass1", "091");
            var user2 = Generator.GenerateUser("user2", "pass2", "098");
            var admin = new Admin {
                Username = "******", Password = "******"
            };

            _userRepo.Save(user1);
            _userRepo.Save(user2);
            _userRepo.Save(admin);

            BasicUser usr = Generator.GenerateUser("dadaa", "nene", "dadads");

            _userRepo.Save(usr);

            Assert.AreEqual(4, _userRepo.RowCount());
            Assert.AreEqual(1, _userRepo.AdminRowCount());

            var admin2 = new Admin {
                Username = "******", Password = "******"
            };

            _userRepo.Save(admin2);
            Assert.AreEqual(2, _userRepo.AdminRowCount());
            Assert.AreEqual(5, _userRepo.RowCount());

            Assert.AreEqual(3, _userRepo.UsersRowCount());
        }
        private void Edit_Worker_Click(object sender, EventArgs e)
        {
            if (listView1.SelectedItems.Count == 0)
            {
                MessageBox.Show("No worker was selected.");
                return;
            }
            else if (listView1.SelectedItems.Count > 1)
            {
                MessageBox.Show("Choose only one worker to delete at the time.");
                return;
            }
            HeadOfDepartmentSQL sql  = new HeadOfDepartmentSQL(SQLConnection.GetSqlConnection());
            BasicUser           temp = new BasicUser();

            temp.FirstName = listView1.SelectedItems[0].SubItems[0].Text;
            temp.LastName  = listView1.SelectedItems[0].SubItems[1].Text;
            temp.Id        = listView1.SelectedItems[0].SubItems[2].Text;
            temp.Age       = int.Parse(listView1.SelectedItems[0].SubItems[3].Text);
            temp.Username  = listView1.SelectedItems[0].SubItems[4].Text;
            String id = temp.Id;
            BasicUser_Registration_Form regForm = new BasicUser_Registration_Form(ref temp, false);

            regForm.FormClosed += new FormClosedEventHandler(FormClosedHandling);
            regForm.ShowDialog();
            sql.UpdateWorker(id, job, temp);
            listView1.Items.Clear();
            sql.LoadAllPeopleInListView(ref this.listView1, job);
        }
        public void InviteUser(BasicUser invitedBy, string comments, FriendProvider friendProvider, IBasicUser contact, bool includeInvitationCode)
        {
            List <IBasicUser> lst = new List <IBasicUser>(1);

            lst.Add(contact);
            InviteUsers(invitedBy, comments, friendProvider, lst, includeInvitationCode);
        }
        private void BasicUsersDataGridView_Click(object sender, System.EventArgs e)
        {
            int selectedBasicUserRow = 0;

            Int32 selectedRowCount =
                this.BasicUsersDataGridView.Rows.GetRowCount(
                    DataGridViewElementStates.Selected);

            // TODO Get selected basic User id
            if (selectedRowCount > 0)
            {
                for (int i = 0; i < selectedRowCount; ++i)
                {
                    selectedBasicUserRow =
                        (this.BasicUsersDataGridView.SelectedRows[i].Index);
                }
            }

            // get selected basic user's informations
            this.selectedBasicUsersDataGridViewRow = new BasicUser(
                id: int.Parse(
                    this.BasicUsersDataGridView
                    .Rows[selectedBasicUserRow].Cells[0].Value.ToString()),
                pin: new PinVAL(value: this.BasicUsersDataGridView
                                .Rows[selectedBasicUserRow].Cells[1].Value.ToString()),
                name: new NameVAL(value: this.BasicUsersDataGridView
                                  .Rows[selectedBasicUserRow].Cells[2].Value.ToString()),
                surname: new SurnameVAL(value: this.BasicUsersDataGridView
                                        .Rows[selectedBasicUserRow].Cells[3].Value.ToString()),
                bankAccount: new BankAccount(state: new MoneyVAL(
                                                 value: decimal.Parse(this.BasicUsersDataGridView
                                                                      .Rows[selectedBasicUserRow].Cells[4].Value.ToString(),
                                                                      CultureInfo.InvariantCulture), currency: Currency.PLN)));
        }
Example #7
0
        public async Task <BasicUser> CreateUser(NewUser user, Guid campusId)
        {
            // get campus and lead for user
            var campus = await _graphGroupService.GetGroupById(campusId);

            var graphUser    = CreateGraphUser(user, Campus.FromMccGroup(campus));
            var userPassword = graphUser.PasswordProfile.Password.ToSecureString();

            graphUser = await _graphService.Client.Users.Request().AddAsync(graphUser);

            // add user to the corresponding groups
            await _graphGroupService.AddUserToGroup(graphUser, _authorizationConfiguration.CommunityGroupId);

            await _graphGroupService.AddUserToGroup(graphUser, campusId);

            // add licence
            await AssignLicense(graphUser);

            // add new user as additional direct to lead
            var lead = await GetLeadForCampus(campus.Id);

            await AssignManager(graphUser, lead.Id);

            // Send welcome mail
            await SendNewUserWelcomeMail(graphUser, user, lead, userPassword);

            return(BasicUser.FromGraphUser(graphUser));
        }
Example #8
0
        /// <summary>
        ///     创建登录标识
        /// </summary>
        public ClaimsIdentity CreateClaimsIdentity(BasicUser user)
        {
            var authenticationScheme = RuntimeContext.Current.WebsiteConfig.AuthenticationScheme;

            var identity = new ClaimsIdentity(authenticationScheme);

            identity.AddClaim(new Claim(
                                  "http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider",
                                  "ASP.NET Identity"));
            identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()));
            identity.AddClaim(new Claim(ClaimTypes.Sid, user.Id.ToString()));
            if (!string.IsNullOrWhiteSpace(user.Tenant))
            {
                identity.AddClaim(new Claim(IdentityClaimTypes.TenantName, user.Tenant));
            }

            if (!string.IsNullOrWhiteSpace(user.UserName))
            {
                identity.AddClaim(new Claim(ClaimTypes.Name, user.UserName));
            }

            if (!string.IsNullOrWhiteSpace(user.Email))
            {
                identity.AddClaim(new Claim(ClaimTypes.Email, user.Email));
            }

            if (!string.IsNullOrWhiteSpace(user.Name))
            {
                identity.AddClaim(new Claim(ClaimTypes.GivenName, user.Name));
            }

            identity.AddClaim(new Claim(ClaimTypes.AuthorizationDecision, user.LoginAuthorizeType.ToString()));
            return(identity);
        }
        private ActionResult EmailCheck(BasicUser user, string email)
        {
            Regex regex = new Regex(@"^[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})$");

            if (regex.IsMatch(email))
            {
                if (user == null)
                {
                    return(Json(new
                    {
                        Exist = false,
                        RegExError = false,
                        Email = HttpUtility.HtmlEncode(email)
                    }));
                }
                return(Json(new
                {
                    Exist = true,
                    RegExError = false,
                    Email = HttpUtility.HtmlEncode(email)
                }));
            }
            return(Json(new
            {
                Exist = true,
                RegExError = true,
                Email = HttpUtility.HtmlEncode(email)
            }));
        }
Example #10
0
        /*  public void printAllCourses(ListView listView)
         * {
         *    listView.Items.Clear();
         *    DataSet dataSet = new DataSet();
         *
         *    String str = "SELECT * FROM CourseTable";
         *    SqlCommand cmd = new SqlCommand(str, SQLConnection.GetSqlConnection());
         *
         *    try
         *    {
         *        SqlDataAdapter adapter = new SqlDataAdapter(cmd);
         *       //DataTable dataTable = new DataTable();
         *        adapter.Fill(dataSet);
         *
         *        for (int i=0;i<dataSet.Tables.Count; i++)
         *        {
         *            DataRow dr = dataSet.Tables[0].Rows[i];
         *            ListViewItem listitem = new ListViewItem(dr[0].ToString());
         *            listitem.SubItems.Add(dr[1].ToString());
         *            listitem.SubItems.Add(dr[2].ToString());
         *            listitem.SubItems.Add(dr[3].ToString());
         *
         *            listView.Items.Add(listitem);
         *        }
         *    }
         *    catch (Exception e)
         *    {
         *        MessageBox.Show(e.Message);
         *    }
         * }  */

        public Boolean AddWorker(BasicUser user, String table)
        {
            if (user == null)
            {
                return(false);
            }

            try
            {
                String str;
                if (table != "SecretaryTable")
                {
                    str  = "INSERT INTO " + table + " VALUES('" + user.FirstName + "','" + user.LastName + "','" + user.Id + "'," + user.Age + ",'" + user.Username + "','" + user.Password + "'";
                    str += "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 0 + "," + 8 + ")";
                }
                else
                {
                    str = "INSERT INTO " + table + " VALUES('" + user.FirstName + "','" + user.LastName + "','" + user.Id + "'," + user.Age + ",'" + user.Username + "','" + user.Password + "')";
                }
                SqlCommand sqlComm = new SqlCommand();
                sqlComm             = sqlConnection.CreateCommand();
                sqlComm.CommandText = str;
                sqlComm.ExecuteNonQuery();
            }
            catch (Exception e) { MessageBox.Show(e.ToString()); }
            return(true);
        }
Example #11
0
        /// <summary>
        ///     登录多租户模式
        /// </summary>
        /// <param name="tenant"></param>
        public async Task SignInTenant(string tenant)
        {
            if (HttpWeb.IsTenant)
            {
                if (tenant.IsNullOrEmpty())
                {
                    throw new ValidException("多租户模式,请设置租户");
                }

                var basicUser = HttpWeb.User;
                if (basicUser == null)
                {
                    basicUser        = new BasicUser();
                    basicUser.Tenant = tenant.ToLower().Trim();
                }

                var claimsPrincipal     = CreateClaimsIdentity(basicUser);
                var httpContextAccessor = Ioc.Resolve <IHttpContextAccessor>();
                await httpContextAccessor.HttpContext.SignInAsync(
                    RuntimeContext.Current.WebsiteConfig.AuthenticationScheme,
                    new ClaimsPrincipal(claimsPrincipal));

                httpContextAccessor = Ioc.Resolve <IHttpContextAccessor>();
            }
        }
Example #12
0
        private async void CreateProfileClick(object sender, EventArgs e)
        {
            // open fragment for profile creation - should support eventhandling and navigation to main content page
            var client = new RestClient("http://10.0.2.2:60408");

            bar.Visibility = Android.Views.ViewStates.Visible;
            users          = await reader.GetUsers(client);

            bar.Visibility = Android.Views.ViewStates.Invisible;

            BasicUser[] baseUsers      = new BasicUser[users.Length];
            var         convertedUsers = (from tempUser in users select new { Username = tempUser.Username,
                                                                              Password = tempUser.Password, Email = tempUser.Email });

            int count = 0;

            foreach (var element in convertedUsers)
            {
                baseUsers[count] = new BasicUser {
                    Username = element.Username, Password = element.Password, Email = element.Email
                };
                count++;
            }



            CreateProfileFrag frag = new CreateProfileFrag(baseUsers);

            frag.CreateEventHandler += Frag_createEventHandler;
            FragmentTransaction transaction = FragmentManager.BeginTransaction();

            frag.Show(transaction, "CreateProfileFrag");
        }
Example #13
0
        public Friend Create(string email, string firstName, string lastName, FriendProvider friendProvider)
        {
            // Validate if the user exists.
            IDictionary <string, object> propertyValues = new Dictionary <string, object>();

            propertyValues.Add("EmailAddress", email);
            BasicUser bu = basicUserRepository.FindOne(propertyValues);

            Friend f = new Friend();

            if (bu != null)
            {
                f.User = bu;
            }
            else
            {
                // If not, create as an invitation
                InvitedUser invited = new InvitedUser();
                invited.EmailAddress = email;
                invited.FirstName    = firstName;
                invited.LastName     = lastName;

                f.User = invited;
            }

            // Set Provider
            f.FriendProvider = friendProvider;
            return(f);
        }
        public async Task <IActionResult> Register(RegisterUserViewModel model)
        {
            if (ModelState.IsValid)
            {
                BasicUser basicUser = new BasicUser
                {
                    FullName = model.FullName,
                    UserName = model.UserName
                };
                var result = await _userManager.CreateAsync(basicUser, model.Password);

                if (result.Succeeded)
                {
                    var signInResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);

                    if (signInResult.Succeeded)
                    {
                        return(RedirectToAction("Index", "Home"));
                    }
                    return(View("Error", new List <string>
                    {
                        "Unknown issue occured during login process"
                    }));
                }
                return(View("Error", result.Errors.Select(c => c.Description).ToList()));
            }
            return(View(model));
        }
        public AdministratorUpdateBasicUserPanel(
            AdministratorUpdateBasicUserPanelVM administratorUpdateBasicUserPanelVM)
        {
            InitializeComponent();

            // Set basic user information
            this.basicUser = administratorUpdateBasicUserPanelVM.basicUser;

            // Fill basic user's labels
            this.BasicUserNameValueLabel.Text         = basicUser._Name._Value;
            this.BasicUserSurnameValueLabel.Text      = basicUser._Surname._Value;
            this.BasicUserPinValueLabel.Text          = basicUser._Pin._Value;
            this.BasicUserAccountStateValueLabel.Text =
                basicUser._BankAccount.state._Value.ToString(new CultureInfo("en-US"));

            // Fill update basic user's text boxes
            this.NameValueTextBox.Text         = basicUser._Name._Value;
            this.SurnameValueTextBox.Text      = basicUser._Surname._Value;
            this.PinValueTextBox.Text          = basicUser._Pin._Value;
            this.AccountStateValueTextBox.Text =
                basicUser._BankAccount.state._Value.ToString(new CultureInfo("en-US"));

            // Hide error label
            this.ErrorLabel.Visible = false;
        }
Example #16
0
        public async Task <IActionResult> PutBasicUser(int id, BasicUser basicUser)
        {
            //Adjusting user
            if (id != basicUser.Id)
            {
                return(BadRequest());
            }

            _context.Entry(basicUser).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!BasicUserExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
Example #17
0
        public void CheckInHouse(Guid housId, Guid userId, string content, List <Asset> asset, GeoPoint location)
        {
            //map the application user to this basic user
            var user    = new BasicUser(userId, "!!Some User Name", "!!Some Nick name");
            var checkin = new CheckIn(user, housId, "some checkin!!", content, asset, location);

            CheckInHouse(housId, checkin);
        }
Example #18
0
        public async Task <ActionResult <BasicUser> > PostBasicUser(BasicUser basicUser)
        {
            //Register
            _context.BasicUser.Add(basicUser);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetBasicUser", new { id = basicUser.Id }, basicUser));
        }
Example #19
0
 public UseCase(Identity id, BasicProject project, BasicUser author, string title, string note, IEnumerable <UseCaseStep> steps)
     : base(id, title)
 {
     Project = project;
     Author  = author;
     Note    = note;
     Steps   = steps;
 }
        public void MockBasicUsersRepository_When_Get(
            string[] basicUsersData, int basicUserId, string basicUserPin,
            string basicUserName, string basicUserSurname,
            decimal basicUserBankAccountValue, Currency basicUserBankAccountCurrency,
            string expected)
        {
            string result = "OK";

            //arrange
            using (StreamWriter sw = new StreamWriter(
                       (cashDispenserLibraryTestSettings._SystemSettings
                        == PlatformType.Windows)
                    ? "cashDispenserDatabase\\BasicUsers.txt"
                    : "cashDispenserDatabase/BasicUsers.txt", false))
            {
                foreach (var basicUserData in basicUsersData)
                {
                    sw.WriteLine(basicUserData);
                }
            }

            //act

            //Connect with database
            MockBasicUsersRepository mockBasicUsersRepository =
                new MockBasicUsersRepository(
                    cashDispenserLibraryTestSettings._SystemSettings);

            //Get information about respectively basic user
            BasicUser gotBasicUser = null;

            try
            {
                gotBasicUser =
                    mockBasicUsersRepository.Get(basicUserId: basicUserId);
            }
            catch (MockBasicUsersRepository_Exception mbur_e)
            {
                result = mbur_e.What();
            }

            //Check got basic user
            if (result.Equals("OK"))
            {
                if ((gotBasicUser._Id != basicUserId) ||
                    (!(gotBasicUser._Pin._Value.Equals(basicUserPin))) ||
                    (!(gotBasicUser._Name._Value.Equals(basicUserName))) ||
                    (!(gotBasicUser._Surname._Value.Equals(basicUserSurname))) ||
                    (gotBasicUser._BankAccount.state._Value != basicUserBankAccountValue) ||
                    (gotBasicUser._BankAccount.state._Currency != basicUserBankAccountCurrency))
                {
                    result = "!!! Issue with get basic user !!!";
                }
            }

            //assert
            Assert.AreEqual(expected: expected, actual: result);
        }
Example #21
0
 public BasicUser Save(BasicUser user)
 {
     using (ITransaction tx = session.BeginTransaction())
     {
         session.Save(user);
         tx.Commit();
         return(user);
     }
 }
Example #22
0
        public void CallBasicUserRegisteration()
        {
            this.Hide();
            BasicUser newUser = null;
            BasicUser_Registration_Form regForm = new BasicUser_Registration_Form(ref newUser, true);

            regForm.ShowDialog();
            this.Close();
        }
 public bool Validate(string userName, string password)
 {
     using (var scope = _ServiceScopeFactory.CreateScope())
     {
         NoteDbContext context = scope.ServiceProvider.GetService <NoteDbContext>();
         BasicUser     user    = context.BasicUsers.Where(uu => uu.UserName == userName && uu.PassWord == password).FirstOrDefault();
         return(user != null);
     }
 }
Example #24
0
        public ActionResult <BasicUser> GetBasicUser(User user)
        {
            if (user == null)
            {
                return(NotFound());
            }

            return(Ok(BasicUser.Create(user)));
        }
Example #25
0
 public void Update(BasicUser user)
 {
     using (var tx = session.BeginTransaction())
     {
         //session.Update(user);
         session.Merge(user);
         tx.Commit();
     }
 }
Example #26
0
 public void Update(BasicUser user)
 {
     foreach (BasicUser u in _users)
     {
         if (u.Id == user.Id)
         {
             u.Username = user.Username;
             u.Password = user.Password;
         }
     }
 }
Example #27
0
        public async Task <BasicUser> GetBasicUserById(Guid userId, UserScope scope)
        {
            var user = await GetGraphUserById(userId);

            if (scope == UserScope.Basic)
            {
                return(BasicUser.FromGraphUser(user));
            }

            return(await AddFullScope(user));
        }
Example #28
0
 public DonationsViewModel(BasicUser currentUser, bool loadDataOnStart = true)
 {
     CurrentUser       = currentUser;
     UserDonationsList = new ObservableCollection <Donation>();
     Title             = $"{UserLabelPrefix} Donations";
     AppModel          = new AppModelContainer();
     if (loadDataOnStart)
     {
         LoadData();
     }
 }
        public BasicUser RegisterUser(BasicUser requestedUser)
        {
            // send request to corresponding Registration service
            Console.WriteLine("Basic user is created!");
            Random rand = new Random();

            requestedUser.PlayerId = rand.Next(12345678, 999999999).ToString();
            Console.WriteLine("With ID: " + requestedUser.PlayerId);
            requestedUser.UserName = "******" + rand.Next(2134, 9999999);
            Console.WriteLine("With Username:" + requestedUser.UserName);
            return(requestedUser);
        }
Example #30
0
 public Requirement(
     Identity id,
     BasicProject project,
     BasicUser author,
     RequirementType type,
     string title,
     string note)
     : base(id, type, title)
 {
     Project = project;
     Author  = author;
     Note    = note;
 }
 public WorklogInput(
     Uri self,
     Uri issueUri,
     BasicUser author,
     BasicUser updateAuthor,
     string comment,
     DateTimeOffset startDate,
     int minutesSpent,
     Visibility visibility,
     AdjustmentEstimate adjustEstimate,
     string adjustEstimateValue)
 {
     Self = self;
     IssueUri = issueUri;
     Author = author;
     UpdateAuthor = updateAuthor;
     Comment = comment;
     StartDate = startDate;
     MinutesSpent = minutesSpent;
     Visibility = visibility;
     AdjustEstimate = adjustEstimate;
     AdjustEstimateValue = adjustEstimateValue;
 }
 public IssueInputBuilder SetAssignee(BasicUser assignee)
 {
     return SetAssigneeName(assignee.Name);
 }
 public WorklogInput(Uri self, Uri issueUri, BasicUser author, BasicUser updateAuthor, string comment, DateTimeOffset startDate, int minutesSpent, Visibility visibility)
     : this(self, issueUri, author, updateAuthor, comment, startDate, minutesSpent, visibility, AdjustmentEstimate.Auto, null)
 {
 }
 public IssueInputBuilder SetReporter(BasicUser reporter)
 {
     return SetReporterName(reporter.Name);
 }