Example #1
0
        public async Task <HttpStatusCode> register(User user)
        {
            user.UserSlug = SlugifyParameterTransformer.GenerateSlug(user.UserMail);
            _ctx.User.Add(user);
            int response = await _ctx.SaveChangesAsync();

            if (response > 0)
            {
                UserCondition userCondition = new UserCondition()
                {
                    UserId       = user.UserId,
                    SuccessCount = 0,
                    FailureCount = 0,
                    UnknownCount = 0
                };

                _ctx.UserCondition.Add(userCondition);
                int responseCondition = await _ctx.SaveChangesAsync();

                if (responseCondition > 0)
                {
                    return(HttpStatusCode.OK);
                }
            }

            return(HttpStatusCode.InternalServerError);
        }
Example #2
0
        public ActionResult List(UserCondition Condition)
        {
            if (Condition.Page <= 0)
            {
                Condition.Page = 1;
            }
            int errorId = CheckRole(_roles);

            if (errorId < 0)
            {
                return(Redirect(errorId));
            }
            if (!userInRoleService.CheckUserRole(-1))
            {
                ViewBag.Message = AdminConfigs.ERROR_ROLE_WRONG;
                return(View("Message"));
            }

            // Gán lại page từ base controller
            Page = Condition.Page;
            ListUserModel listUser = new ListUserModel();

            listUser.Condition = Condition;
            LoadData(ref listUser);

            return(View(listUser));
        }
Example #3
0
        public IPagedList <User> SearchUsers(UserCondition condition)
        {
            var query = new Repository <User>().Table;

            if (!string.IsNullOrEmpty(condition.UserName))
            {
                query = query.Where(t => t.UserName.Contains(condition.UserName));
            }
            if (condition.UserType != null)
            {
                query = query.Where(t => t.UserType == condition.UserType);
            }
            if (condition.BeginDate != null)
            {
                query = query.Where(u => u.CreateDate >= condition.BeginDate);
            }
            if (condition.EndDate != null)
            {
                query = query.Where(u => u.CreateDate <= condition.EndDate);
            }
            query = query.Where(t => t.IsDelete == false);
            query = query.Where(t => t.UserType != UserType.Supper);
            query = query.OrderByDescending(t => t.CreateDate);

            return(new PagedList <User>(query, condition.PageIndex, condition.PageSize));
        }
Example #4
0
        public ActionResult Index(UserCondition condition)
        {
            var users  = userService.SearchUsers(condition);
            var models = new PagedList <UserModel>(users.Select(n => n.ToModel()), users.Paging);

            return(View(models));
        }
Example #5
0
        public IActionResult SignIn(UserCondition condition)
        {
            var model = _userService.LoginUser(
                new Entities.User
            {
                UserId       = condition.UserId,
                UserPassword = condition.UserPassword
            });

            if (model == null)
            {
                throw new Exception("No data");
            }

            var token = _tokenManager.Create(model);

            model.UserToken = token.RefreshToken;

            var result = _userService.Update(model);

            if (result.Success == false)
            {
                throw new Exception("Please contact MIS");
            }

            return(Ok(token));
        }
Example #6
0
 public ActionResult Index()
 {
     var condition = new UserCondition();
     var datas = UserBiz.Search(condition);
     var model = PDM.Create(datas, condition);
     return View(model);
 }
Example #7
0
        private async Task HandleUserData(Activity activity)
        {
            using (ILifetimeScope scope = DialogModule.BeginLifetimeScope(Conversation.Container, activity))
            {
                IAddress address = Address.FromActivity(activity);
                IBotDataStore <BotData> botDataStore = scope.Resolve <IBotDataStore <BotData> >();
                BotData userData = await botDataStore.LoadAsync(address, BotStoreType.BotUserData, CancellationToken.None);

                User user = userData.GetProperty <User>("User");

                if (user == null)
                {
                    IUserService  userService = scope.Resolve <IUserService>();
                    UserCondition condition   = new UserCondition()
                    {
                        LineUserId = activity.From.Id,
                        UserName   = activity.From.Name
                    };
                    user = userService.GetOrCreate(condition);

                    userData.SetProperty("User", user);
                    await botDataStore.SaveAsync(address, BotStoreType.BotUserData, userData, CancellationToken.None);

                    await botDataStore.FlushAsync(address, CancellationToken.None);
                }
            }
        }
Example #8
0
        public async Task <ProfileStatisticDto> updateConditionOfPost(PostConditionDto postConditionDto)
        {
            UserCondition userCondition = await _post.updateConditionOfPost(postConditionDto);

            ProfileStatisticDto profileStatisticDto = _mapper.Map <ProfileStatisticDto>(userCondition);

            return(profileStatisticDto);
        }
Example #9
0
        public async Task <ProfileStatisticDto> deletePost(DeletePostDto deletePostDto)
        {
            UserCondition userCondition = await _post.deletePost(deletePostDto);

            ProfileStatisticDto profileStatisticDto = _mapper.Map <ProfileStatisticDto>(userCondition);

            return(profileStatisticDto);
        }
Example #10
0
        /// <summary>
        /// Get List Assignment By User
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="companycode"></param>
        /// <returns>List of assignment</returns>
        public IList <dynamic> GetListPriceInfor(UserCondition condition, string companycode, int sort_colum, string sort_type)
        {
            var listAssignment = this._repository.GetListPriceInfor(
                condition,
                companycode,
                sort_colum,
                sort_type);

            return(listAssignment);
        }
Example #11
0
        public User GetOrCreate(UserCondition condition)
        {
            User user = Get(condition);

            if (user == null)
            {
                user = _userDao.Create(condition.LineUserId, condition.UserName);
            }

            return(user);
        }
Example #12
0
        public ActionResult PersonalView(UserCondition condition)
        {
            if (condition == null)
            {
                return(Redirect((int)Errors.ROLE_WRONG));
            }
            if (condition.id == 0)
            {
                return(null);
            }

            // Check Login user is Admin
            if (!CheckIsAdmin())
            {
                return(Redirect((int)Errors.ROLE_WRONG));
            }

            Models.UserViewModel m = new UserViewModel();
            m.Condition = condition;

            Models.UserModel temp = new UserModel();

            LoadDataPersonalInfo(condition.id, ref temp, false);

            m.User = temp;

            int total = 0;

            m.ListUser = userService.ListItem(condition.RegionId, condition.RoleId, condition.SearchText, 1, 100, out total);

            List <Entities.Item> lstItem = new List <Item>();
            // Get list regions.
            RegionService regionService = new RegionService();

            lstItem = null;
            lstItem = regionService.ListItemActive();
            lstItem.Insert(0, new Item {
                Text = "-- Chọn vùng --", Id = -1
            });
            ViewBag.ListRegion = lstItem;

            // Get list role.
            lstItem = null;
            lstItem = roleService.ListItem();
            lstItem.Insert(0, new Item {
                Text = "-- Chọn quyền --", Id = -1
            });
            ViewBag.ListRole = lstItem;

            ViewBag.ActionSubMenu = "";
            return(View(m));
        }
Example #13
0
        public void CreateTree(ExpressionTreeNode <TEntity> node)
        {
            string logic = AND;

            node.Query = REGEX_AND.Replace(node.Query, "#", 1, 0);
            var list = node.Query.Split("#");

            if (list.Length == 1)
            {
                int endAt = 0;
                if (list[0][0] == '(')
                {
                    node.Query = list[0].Substring(1, list[0].Length - 2);
                    IsValid(node.Query, out endAt);
                }
                logic      = Regex.Match(node.Query.Substring(endAt, node.Query.Length - 1 - endAt), AND_OR).Value;
                node.Query = REGEX_AND_OR.Replace(node.Query, "#", 1, endAt);
                list       = node.Query.Split("#");
                if (list.Length == 1)
                {
                    var data = REGEX_OPERATOR.Split(node.Query);
                    var cond = new UserCondition {
                        Key = data[0], Value = data[2], Operator = data[1]
                    };
                    node.Data = GetCriterion(cond);
                    return;
                }
            }
            node.LogicalOperator = logic;
            var left = new ExpressionTreeNode <TEntity>()
            {
                Query = list[0]
            };

            node.Left = left;
            CreateTree(node.Left);
            var right = new ExpressionTreeNode <TEntity>()
            {
                Query = list[1]
            };

            node.Right = right;
            CreateTree(node.Right);
            if (node.LogicalOperator == "AND")
            {
                node.Data = new AndCriterion <TEntity>(left.Data, right.Data);
            }
            else
            {
                node.Data = new OrCriterion <TEntity>(left.Data, right.Data);
            }
        }
Example #14
0
        /// <summary>
        /// Search project by condition
        /// </summary>
        /// <param name="model">model</param>
        /// <param name="condition">condition</param>
        /// <returns>Search result</returns>
        public PageInfo <dynamic> SearchAssignmentByUser(DataTablesModel model, UserCondition condition, string companycode)
        {
            var pageInfo = this._repository.SearchAssignmentByUser(
                model.iDisplayStart,
                model.iDisplayLength,
                model.sColumns,
                model.iSortCol_0,
                model.sSortDir_0,
                condition,
                companycode);

            return(pageInfo);
        }
Example #15
0
        /// <summary>
        /// Search Individual Sales ByUser
        /// </summary>
        /// <param name="startItem"></param>
        /// <param name="itemsPerPage"></param>
        /// <param name="columns"></param>
        /// <param name="sortCol"></param>
        /// <param name="sortDir"></param>
        /// <param name="condition"></param>
        /// <param name="companycode"></param>
        /// <returns></returns>
        public IList <dynamic> SearchPriceInforByUser(
            int startItem,
            int itemsPerPage,
            string columns,
            int?sortCol,
            string sortDir,
            UserCondition condition,
            string companycode)
        {
            Sql sql      = SearchPriceInforByUser(condition, companycode, 0, string.Empty, startItem, itemsPerPage, columns, sortCol, sortDir);
            var pageInfo = _database.Fetch <dynamic>(sql);

            return(pageInfo);
        }
Example #16
0
        public IActionResult PhysicallyRemove([FromQuery] UserCondition c)
        {
#if DEBUG
            DataConnection.TurnTraceSwitchOn();
            DataConnection.WriteTraceLine = (msg, context) => Debug.WriteLine(msg, context);
#endif
            using (var db = new peppaDB())
            {
                var count = db.User
                            .Where(c.CreatePredicate())
                            .Delete();
                return(Ok(count));
            }
        }
Example #17
0
        /// <summary>
        /// Search By User
        /// </summary>
        /// <param name="startItem"></param>
        /// <param name="itemsPerPage"></param>
        /// <param name="columns"></param>
        /// <param name="sortCol"></param>
        /// <param name="sortDir"></param>
        /// <param name="condition"></param>
        /// <param name="companycode"></param>
        /// <returns></returns>
        public PageInfo <dynamic> SearchAssignmentByUser(
            int startItem,
            int itemsPerPage,
            string columns,
            int?sortCol,
            string sortDir,
            UserCondition condition,
            string companycode)
        {
            Sql sql      = buildSelectQueryByUser(condition, companycode, false, 0, string.Empty);
            var pageInfo = Page <dynamic>(startItem, itemsPerPage, columns, sortCol, sortDir, sql);

            return(pageInfo);
        }
Example #18
0
        public IActionResult Count([FromQuery] UserCondition c)
        {
#if DEBUG
            DataConnection.TurnTraceSwitchOn();
            DataConnection.WriteTraceLine = (msg, context) => Debug.WriteLine(msg, context);
#endif
            using (var db = new peppaDB())
            {
                var count =
                    c == null?db.User.Count() :
                        db.User.Count(predicate: c.CreatePredicate());

                return(Ok(count));
            }
        }
Example #19
0
        protected override ICriterion <Aps> GetCriterion(UserCondition cond)
        {
            ICriterion <Aps> criterion = null;

            switch (cond.Key.ToLower())
            {
            case "apsid":
                criterion = new ApsIdCriterion(cond) as ICriterion <Aps>;
                break;

            default:
                break;
            }
            return(criterion);
        }
Example #20
0
        public IActionResult Remove([FromQuery] UserCondition c)
        {
#if DEBUG
            DataConnection.TurnTraceSwitchOn();
            DataConnection.WriteTraceLine = (msg, context) => Debug.WriteLine(msg, context);
#endif
            using (var db = new peppaDB())
            {
                var count = db.User
                            .Where(c.CreatePredicate())
                            .Set(_ => _.modified_by, CurrentAccountId)
                            .Set(_ => _.removed_at, Sql.CurrentTimestampUtc)
                            .Update();
                return(Ok(count));
            }
        }
Example #21
0
        private async void DeleteCondition(UserCondition existing)
        {
            if (existing == null)
            {
                return;
            }

            bool delete = await UserDialogs.Instance.ConfirmAsync(
                AppResources.ConditionEdit_deleteWarningMessage,
                AppResources.ConditionEdit_deleteWarningTitle,
                AppResources.Dialog_delete,
                AppResources.Dialog_cancel
                );

            if (!delete)
            {
                return;
            }

            UserDialogs.Instance.ShowLoading(AppResources.Dialog_loading);
            bool deletionSuccess = await NetworkUtils.DeleteRequest("api/UserConditions/" + existing.Id);

            UserDialogs.Instance.HideLoading();

            if (!deletionSuccess)
            {
                UserDialogs.Instance.Alert(AppResources.ConditionEdit_deleteError, AppResources.Error_delete);
                return;
            }
            else
            {
                App.ShouldUpdate = true;

                App.db.DeleteReminder(existing.Id);
                App.db.DeleteCondition(existing.Id);
                App.db.DeleteUploadsForCondition(existing.Id);

                await UserDialogs.Instance.AlertAsync(
                    AppResources.ConditionEdit_deleteSuccessMessage,
                    AppResources.ConditionEdit_deleteSuccessTitle
                    );

                await App.Homepage.Navigation.PopAsync();

                await App.Homepage.Navigation.PopAsync();
            }
        }
Example #22
0
        public IEnumerable<UserInfo> Search(UserCondition condition)
        {
            using (var db = new Entities())
            {
                var currentUser = CurrentUserBiz.CurrentUser;
                var query = db.UserInfo.Where(q => q.Status == (int) StatusEnum.Valid);

                query = condition.Filter(query);

                if (currentUser != null)
                {
                    query = query.Where(q => q.UserType >= currentUser.UserType);
                }

                return query.OrderBy(q => q.UserCode).DoPage(condition.Pager).ToList();
            }
        }
Example #23
0
        public ActionResult getUserList(UserCondition condition)
        {
            if (condition == null)
            {
                condition = new UserCondition();
            }
            int         pagesize = int.Parse(Request["rows"]);
            int         pagenum  = int.Parse(Request["page"]);
            int         count;
            UserDao     dao  = new UserDao();
            List <User> list = dao.getList(condition, pagesize, pagenum, out count);

            dao.Dispose();
            JsonData data = new JsonData();

            data.rows  = list;
            data.total = count;
            return(Json(data));
        }
Example #24
0
        public async Task <ListResult <User> > GetDataList(UserCondition condition)
        {
            Expression <Func <User, bool> > where = PredicateExtensions.True <User>();
            if (!string.IsNullOrEmpty(condition.UserName))
            {
                where = where.And(a => a.UserName.Contains(condition.UserName));
            }
            if (!string.IsNullOrEmpty(condition.Phone))
            {
                where = where.And(a => a.Phone.Contains(condition.Phone));
            }
            var list = await base.GetPageAsync(where, w => w.CreateTime, condition.PageIndex, condition.PageSize);

            foreach (var item in list.Item2)
            {
                item.RoleStr = await _role.GetRoleName(item.Id);
            }
            return(new ListResult <User>(condition.PageIndex, condition.PageSize, list.Item1, list.Item2));
        }
Example #25
0
        protected override ICriterion <Motor> GetCriterion(UserCondition cond)
        {
            ICriterion <Motor> criterion = null;

            switch (cond.Key.ToLower())
            {
            case "motorvehicleid":
                criterion = new MotorVehicleIdCriterion(cond) as ICriterion <Motor>;
                break;

            case "shottime":
                criterion = new MotorVehicleShotTimeCriterion(cond) as ICriterion <Motor>;
                break;

            default:
                break;
            }
            return(criterion);
        }
Example #26
0
        public IEnumerable <UserOut> GetUsersList(UserCondition input, out int totalCount)
        {
            var sqlParamters = new List <SqlParameter>();

            sqlParamters.Add(new SqlParameter("@pageindex", input.Page));
            sqlParamters.Add(new SqlParameter("@pagesize", input.Limit));
            sqlParamters.Add(new SqlParameter("@name", input.Name ?? ""));
            sqlParamters.Add(new SqlParameter("@email", input.Email ?? ""));
            var outParameter = new SqlParameter("@count", SqlDbType.Int, 4);

            outParameter.Direction = ParameterDirection.Output;
            sqlParamters.Add(outParameter);

            var r = Repository.ExecuteQuery <UserOut>("EXEC sp_GetPageUsers @pageindex,@pagesize,@name,@email,@count out", sqlParamters.ToArray());

            totalCount = Convert.ToInt32(outParameter.Value == DBNull.Value ? 0 : outParameter.Value);

            return(r);
        }
Example #27
0
        private void UserDefineTxt_SelectedIndexChanged(object sender, EventArgs e)
        {
            UserCondition.Clear();

            string SelDefineTxt = string.Format(@"{0}\{1}", UserDefineTxtPath, UserDefineTxt.Text + ".txt");

            string[] TxtData = System.IO.File.ReadAllLines(SelDefineTxt);
            for (int i = 0; i < TxtData.Length; i++)
            {
                if (i == 0)
                {
                    UserCondition.Text = TxtData[i];
                }
                else
                {
                    UserCondition.Text = UserCondition.Text + "\r\n" + TxtData[i];
                }
            }
        }
Example #28
0
        protected override ICriterion <Person> GetCriterion(UserCondition cond)
        {
            ICriterion <Person> criterion = null;

            switch (cond.Key.ToLower())
            {
            case "personid":
                criterion = new PersonIdCriterion(cond) as ICriterion <Person>;
                break;

            case "shottime":
                criterion = new PersonShotTimeCriterion(cond) as ICriterion <Person>;
                break;

            default:
                break;
            }
            return(criterion);
        }
Example #29
0
        public User Get(UserCondition condition)
        {
            DynamicParameters parameters = new DynamicParameters();

            StringBuilder builder = new StringBuilder();

            builder.Append("select * from SKR_USER_M as u");

            if (!string.IsNullOrWhiteSpace(condition.LineUserId))
            {
                builder.Append(" where u.USER_LINE_ID = @lineUserId");
                parameters.Add("@lineUserId", condition.LineUserId);
            }

            User result = null;

            using (DbFixture)
            {
                try
                {
                    IEnumerable <dynamic> dataRows = DbFixture.Db.Connection.Query(builder.ToString(), parameters);

                    if (dataRows != null && dataRows.Count() > 0)
                    {
                        IDictionary <string, object> row = dataRows.FirstOrDefault() as IDictionary <string, object>;

                        result = new User()
                        {
                            Id         = row["USER_SEQ_NO"] as string,
                            Name       = row["USER_LINE_NAME"] as string,
                            LineUserId = row["USER_LINE_ID"] as string,
                            CreateDate = row["CRE_DTE"] as DateTime?
                        };
                    }
                }
                catch (Exception exception)
                {
                    Logger.Write(Domain.Enum.EnumLogCategory.Error, exception.ToString());
                }
            }

            return(result);
        }
Example #30
0
        public async Task <UserCondition> deletePost(DeletePostDto deletePostDto)
        {
            Post post = await _ctx.Post.Where(m => m.UserId == deletePostDto.UserId &&
                                              m.PostId == deletePostDto.PostId).FirstOrDefaultAsync();

            UserCondition userCondition = new UserCondition();

            if (post != null)
            {
                post.DeletedDate = DateTime.Now;

                _ctx.Update(post);
                int response = await _ctx.SaveChangesAsync();

                if (response > 0)
                {
                    userCondition = await _ctx.UserCondition.Where(m => m.UserId == deletePostDto.UserId).FirstOrDefaultAsync();

                    if (post.Condition == 0)
                    {
                        userCondition.UnknownCount -= 1;
                    }
                    else if (post.Condition == 1)
                    {
                        userCondition.SuccessCount -= 1;
                    }
                    else
                    {
                        userCondition.FailureCount -= 1;
                    }
                    _ctx.UserCondition.Update(userCondition);
                    int conditionResponse = await _ctx.SaveChangesAsync();

                    if (conditionResponse > 0)
                    {
                        return(userCondition);
                    }
                }
            }

            return(userCondition);
        }
Example #31
0
        public override ActionResult NodeView(CustomPermissionsCondition collections)
        {
            string        menuid = Request["menuid"];
            UserListModel model;
            string        name      = Request["name"];
            string        pageindex = Request["pageindex"];
            UserService   us        = new UserService();
            UserCondition uc        = new UserCondition();

            uc.UserName  = name;
            uc.PageSize  = 6;
            uc.PageIndex = int.Parse(pageindex);
            Paging      page = new Paging(uc);
            List <User> list = us.GetListUaRcallCondition(uc, ref page, menuid).ToList();

            model           = new UserListModel(list);
            model.Paging    = page;
            model.condition = uc;
            return(PartialView("_Organization", model));
        }
Example #32
0
        public IActionResult SearchFull([FromQuery] UserCondition c, [FromQuery] string[] order, int currentPage = 1, int pageSize = 10)
        {
#if DEBUG
            DataConnection.TurnTraceSwitchOn();
            DataConnection.WriteTraceLine = (msg, context) => Debug.WriteLine(msg, context);
#endif
            using (var db = new peppaDB())
            {
                var q = db.User
                        .LoadWith(_ => _.SexType)
                        .LoadWith(_ => _.NameList.First().PersonNameType)
                        .LoadWith(_ => _.AddressList.First().AddressType)
                        .LoadWith(_ => _.ContactList.First().ContactType);

                var filtered = c == null ? q : q.Where(c.CreatePredicate());
                var ordered  = order.Any() ? filtered.SortBy(order) : filtered;

                return(Ok(ordered.Skip((currentPage - 1) * pageSize).Take(pageSize).ToList()));
            }
        }