public IActionResult AddFavCategory(int categoryid)
{
Console.WriteLine("********************************");
Console.WriteLine(categoryid);
Console.WriteLine("********************************");
int?userID = HttpContext.Session.GetInt32("LogedUserID");
if (userID != null)
{
dbUser = _context.users.SingleOrDefault(u => u.id == userID);
if (dbUser != null)
{
Categories category = _context.categories
.SingleOrDefault(cat => cat.id == categoryid);
UserCategory uc = new UserCategory()
{
Category = category,
User = dbUser
};
dbUser.UserCategory.Add(uc);
category.UserCategory.Add(uc);
_context.Add(uc);
_context.SaveChanges();
}
}
return(RedirectToAction("Index", "Home"));
}
protected void btnOK_Click(object sender, EventArgs e)
{
try
{
if (Valid())
{
this.labelControl2.Focus();
OperateReturnInfo opr = null;
UserInfo Curr = bsUser.Current as UserInfo;
UserCategory cate = lookUpEdit1.EditValue as UserCategory;
String categoryCode = lookUpEdit1.EditValue.ToString();
if (Curr != null)
{
opr = AGVDAccess.AGVClientDAccess.saveUSer(Curr, categoryCode);
MsgBox.Show(opr);
if (opr.ReturnCode == OperateCodeEnum.Success)
{
this.DialogResult = DialogResult.OK;
this.Close();
}
}
}
}
catch (Exception ex)
{
MsgBox.ShowError(ex.Message);
}
}
public void AddDefaultCategories(string userID)
{
userID.CheckForNull(nameof(userID));
var user = _context.Users.Single(t => t.Id == userID);
user.UserCategories = new List <UserCategory>();
var startupCategories = _context.Categories
.Where(category => (category.CreatedByID == null) || (category.IsSystem))
.ToList();
foreach (var category in startupCategories)
{
var userCategory = new UserCategory()
{
CategoryID = category.ID,
UserId = user.Id
};
user.UserCategories.Add(userCategory);
}
_context.SaveChanges();
}
public void delCategory_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
try
{
gvCategory.CloseEditor();
gvUser.CloseEditor();
if (bsCategory.Count <= 0)
{
return;
}
if (MsgBox.ShowQuestion("确定删除当前用户分类吗?") == DialogResult.Yes)
{
UserCategory curr = bsCategory.Current as UserCategory;
if (curr != null)
{
OperateReturnInfo opr = AGVDAccess.AGVClientDAccess.DelCategory(curr);
if (opr.ReturnCode == OperateCodeEnum.Success)
{
this.bsCategory.DataSource = AGVDAccess.AGVClientDAccess.get_Category();
bsCategory.ResetBindings(false);
this.bsUser.DataSource = AGVDAccess.AGVClientDAccess.LoadUserByCategoryCode(curr.CategoryCode);
bsUser.ResetBindings(false);
bsSysOperButton.DataSource = AGVDAccess.AGVClientDAccess.load_Button();
bsSysOperButton.ResetBindings(false);
gvCategory_FoucsedRowChanged(null, null);
}
MsgBox.Show(opr);
}
}
}
catch (Exception ex)
{
MsgBox.ShowError(ex.Message);
}
}
private bool Valid()
{
try
{
gvCategory.CloseEditor();
gvUser.CloseEditor();
gvOperButton.CloseEditor();
if (bsCategory.Count > 0)
{
UserCategory currCategory = bsCategory[gvCategory.FocusedRowHandle] as UserCategory;
if (currCategory == null)
{
return(false);
}
if (String.IsNullOrEmpty(currCategory.CategoryName))
{
MsgBox.ShowWarn("请维护分类名称！");
return(false);
}
}
return(true);
}
catch (Exception ex)
{
MsgBox.ShowError(ex.Message);
return(false);
}
}
private async void menageModeratorRoleForUser(Category category, ApplicationUser user)
{
string userId = user?.Id;
var userRoles = await _userManager.GetRolesAsync(user);
if (!userRoles.Contains("Admin"))
{
int usersPostsForCategory = _userService.CountApprovedPostsFromUserForCategory(userId, category.ID);
int postBeforeDelete = usersPostsForCategory + 1;
if (usersPostsForCategory < category.PostRule && postBeforeDelete == category.PostRule)
{
int moderatorCategories = _userService.countModeratorCategories(userId);
moderatorCategories -= 1;
UserCategory obj = new UserCategory();
obj.UserId = user.Id;
obj.User = user;
obj.CategoryId = category.ID;
obj.Category = category;
int deleteResult = await _userCategoryService.DeleteAsync(obj);
if (moderatorCategories == 0)
{
var result = await _userManager.RemoveFromRoleAsync(user, "Moderator");
}
}
}
}
public async Task <ActionResult <UserCategory> > PostUserCategory(UserCategory userCategory)
{
_context.UserCategory.Add(userCategory);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserCategory", new { id = userCategory.UserCategoryID }, userCategory));
}
private void FrmAddCategory_Shown(object sender, EventArgs e)
{
try
{
CenterToParent();
UserCategory newUercate = new UserCategory();
IList <UserCategory> listcate = new List <UserCategory>();
listcate = AGVDAccess.AGVClientDAccess.select_TheLastFromCategory();
if (Set == 1)
{
newUercate.CategoryCode = categoryCode;
newUercate.CategoryName = categoryName;
}
else
{
if (listcate.Count > 0)
{
newUercate.CategoryCode = (int.Parse(listcate[0].CategoryCode) + 1).ToString().PadLeft(4, '0');
}
else
{
newUercate.CategoryCode = "0001";
}
}
bsCategory.DataSource = newUercate;
bsCategory.ResetBindings(false);
}
catch (Exception ex)
{
MsgBox.ShowError(ex.Message);
}
}
/// <summary>
/// 感兴趣的类目
/// </summary>
/// <param name="userid"></param>
/// <param name="categoryids"></param>
/// <returns></returns>
public virtual int InterstingCategory(int userid, int[] categoryids)
{
if (userid > 0)
{
ISession Session = null;
ITransaction transaction = null;
try
{
Session = DBHelper.SessionFactory.OpenSession();
transaction = Session.BeginTransaction();
foreach (int categoryid in categoryids)
{
UserCategory item = new UserCategory();
item.UserID = userid;
item.CategoryID = categoryid;
Session.Save(item);
}
transaction.Commit();
return(1);
}
catch (Exception ex)
{
transaction.Rollback();
LogHelper.WriteLog("用户提交感兴趣的类目保存出错：" + ex.Message, "Execption_Dal.txt");
return(0);
}
finally
{
transaction.Dispose();
Session.Close();
Session.Dispose();
}
}
return(0);
}
public ResponseModel PostCategory([FromBody] Category category)
{
string name = category.NameCate;
string image = category.ImageCate;
int id_type = category.Id_type;
UserCategory userCategory = new UserCategory();
Category category1 = _context.Categories.Where(m => m.NameCate == category.NameCate).FirstOrDefault();
try
{
if (category1 == null)
{
category.NameCate = name;
category.ImageCate = image;
category.Id_type = id_type;
_context.Categories.Add(category);
_context.SaveChanges();
ResponseModel res = new ResponseModel("Create success", null, "200");
return(res);
}
else
{
ResponseModel res = new ResponseModel("Category has existed", null, "200");
return(res);
}
}
catch
{
ResponseModel res = new ResponseModel("Create fail", null, "200");
return(res);
}
}
public Category(UserCategory category)
{
Id = category.id;
Name = category.name;
Description = category.description;
Product = new List <model.Product>();
}
public async Task <int> DeleteAsync(UserCategory userCategory)
{
_context.Remove(userCategory);
int removed = await _context.SaveChangesAsync();
return(removed);
}
public async Task <UserCategory> Insert(UserCategory userCategory)
{
_context.Add(userCategory);
await _context.SaveChangesAsync();
return(userCategory);
}
public async Task <IActionResult> PutUserCategory(int id, UserCategory userCategory)
{
if (id != userCategory.UserCategoryID)
{
return(BadRequest());
}
_context.Entry(userCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static MobsError Create(UserCategoryModel model)
{
var context = "UserCategoryProvider.Create";
try
{
using (var db = new dbMobs())
{
if (db.UserCategories.Any(e => e.Name == model.Name && e.UserId == model.UserId))
{
return(new MobsError(context, MobsErrorEnum.EmailAddressInUse));
}
var dbe = new UserCategory
{
Name = model.Name, UserId = model.UserId,
};
db.UserCategories.Add(dbe);
db.SaveChanges();
model.Id = dbe.Id;
}
}
catch (Exception e)
{
new MobsError(context, e);
}
return(null);
}
public async Task <StatusData <string> > CategoryFriendsCopy(CopyCategory request, SystemSession session)
{
var userCategory = new UserCategory {
UserId = session.UserId.ToString()
};
var friends = string.Join(",", request.Friends);
var result = new StatusData <string>();
var isOperationSuccessful = true;
foreach (var categoryId in request.TargetCategories)
{
userCategory.UserCategoryTypeId = categoryId;
var serviceResponse = await Task.Factory.StartNew(() => Client.UserService.insertInCategory(userCategory, friends, session.GetSession())).ConfigureAwait(false);
isOperationSuccessful &= ((SystemDbStatus)serviceResponse.DbStatusCode).IsOperationSuccessful();
}
if (request.RemoveFromSource)
{
userCategory.UserCategoryTypeId = request.CategoryId;
var serviceResponse = await Task.Factory.StartNew(() => Client.UserService.removeFromCategory(userCategory, friends, session.GetSession())).ConfigureAwait(false);
isOperationSuccessful &= ((SystemDbStatus)serviceResponse.DbStatusCode).IsOperationSuccessful();
}
result.Status = isOperationSuccessful ? SystemDbStatus.Inserted : SystemDbStatus.Duplicate;
return(result);
}
private void AddUserCategories(IList <CategoryViewModel> levels, User user)
{
if (levels == null)
{
return;
}
foreach (CategoryViewModel item in levels)
{
CategoryFavouriteLevel level = _categoryFavouriteLevelService.FindById(item.LevelId);
if (level == null)
{
continue;
}
foreach (Guid categoryId in item.SelectedCatagories)
{
Category category = _categoryService.FindById(categoryId);
if (category == null)
{
continue;
}
var userCategory = new UserCategory {
User = user,
Category = category,
CategoryFavouriteLevel = level
};
_userCategoryService.Create(userCategory);
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserId,CategoryId,MinutesSpent,DatePicked")] UserCategory userCategory)
{
if (id != userCategory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(userCategory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserCategoryExists(userCategory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryId"] = new SelectList(_context.Categories, "Id", "Id", userCategory.CategoryId);
ViewData["UserId"] = new SelectList(_context.User, "Id", "Id", userCategory.UserId);
return(View(userCategory));
}
public Response Add(UserCategory value)
{
Response response = new Response();
try
{
var exist = List().usercategories.Where(x => x.CatName.ToLower() == value.CatName.ToLower());
if (exist.Count() > 0)
{
response.Status = false;
response.Description = "Record already exists";
return(response);
}
using (IDbConnection conn = GetConnection())
{
conn.Insert(value);
response.Status = true;
response.Description = "Successful";
}
}
catch (Exception ex)
{
response.Status = false;
response.Description = ex.Message;
}
return(response);
}
public async Task <IActionResult> PutUserCategory([FromRoute] int id, [FromBody] UserCategory userCategory)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userCategory.Id_UserCategory)
{
return(BadRequest());
}
_context.Entry(userCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <PaginatedResponse <IEnumerable <FriendsInCategoryResponse> > > GetFriendsInCategory(PaginatedRequest <FriendsInCategoryRequest> request, SystemSession session)
{
var serviceRequest = new UserCategory
{
UserId = session.UserId.ToString(),
UserCategoryTypeId = request.Data.CategoryId,
InvertCatSerch = request.Data.InvertCategorySearch,
PageIndex = request.PageIndex,
PageSize = request.PageSize + 1
};
var data = await Task.Factory.StartNew(() => Client.UserService.getUserFriendsInCategory(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = new PaginatedResponse <IEnumerable <FriendsInCategoryResponse> >
{
Page = data.Select(x => new FriendsInCategoryResponse
{
UserId = x.UserId,
UserName = x.UserName,
Image = x.Picture,
FirstName = x.FirstName,
LastName = x.LastName,
Title = x.Title,
UserTypeId = (SystemUserType)x.UserTypeId,
Email = x.Email
}).Take(request.PageSize),
HasNextPage = data.Count > request.PageSize
};
return(result);
}
public static void SeedUserPermitedCategoties(IApplicationBuilder applicationBuilder)
{
using var serviceScope = applicationBuilder?.ApplicationServices.GetRequiredService <IServiceScopeFactory>().CreateScope();
ApplicationDbContext context = serviceScope.ServiceProvider.GetService <ApplicationDbContext>();
if (context.UserCategories?.Count() < 1)
{
var adminUser = context.Users.Where(x => x.Email == "*****@*****.**").FirstOrDefault();
var chiefEditor = context.Users.Where(x => x.Email == "*****@*****.**").FirstOrDefault();
var categories = context.Categories.ToList();
for (int p = 0; p < categories.Count; p++)
{
UserCategory userCat = new UserCategory();
userCat.UserId = adminUser.Id;
userCat.CategoryId = categories[p].Id;
context.UserCategories.Add(userCat);
}
for (int p = 0; p < categories.Count; p++)
{
UserCategory userCat = new UserCategory();
userCat.UserId = chiefEditor.Id;
userCat.CategoryId = categories[p].Id;
context.UserCategories.Add(userCat);
}
context.SaveChanges();
}
}
public void Should_Construct_UserCategory()
{
UserCategory userCategory = new UserCategory(categoryName, summary);
_ = new UserCategory();
_ = userCategory.Id;
userCategory.ShouldNotBeNull();
}
public ActionResult DeleteConfirmed(int id)
{
UserCategory userCategory = db.Categories.Find(id);
db.Categories.Remove(userCategory);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private static int CompareCategories(UserCategory cat1, UserCategory cat2)
{
if (cat1 == cat2)
{
return(0);
}
return(cat1 < cat2 ? -1 : 1);
}
public async Task <StatusData <string> > UpdateCategory(CategoryUpdateRequest request, SystemSession session)
{
var userCategory = new UserCategory {
UserId = session.UserId.ToString(), UserCategoryTypeId = request.CategoryId, Name = request.Name, Description = request.Description
};
var result = (await Task.Factory.StartNew(() => Client.UserService.editCategoryMeta(userCategory, session.GetSession())).ConfigureAwait(false)).GetStatusData <string>();
return(result);
}
private static int CompareCategoryToChangeWrapper(UserCategory cat, ChangeWrapper wrapper)
{
if (cat == wrapper.Category)
{
return(-1);
}
return(CompareCategories(cat, wrapper.Category));
}
public async Task AddUsertoCategory(UserCategory userCategory)
{
using (var context = new ConviceContext())
{
var entry = context.Entry(userCategory);
entry.State = EntityState.Added;
await context.SaveChangesAsync();
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
UserCategory userCategory = await db.Categories.FindAsync(id);
db.Categories.Remove(userCategory);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public IActionResult RemoveFavCategory(int id)
{
UserCategory usercat = _context.usersCategory
.SingleOrDefault(uc => uc.id == id);
_context.Remove(usercat);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public async Task UserCategoryAggregateRootCanBeConstructedFromMemento()
{
// Arrange
// No version - it's new
var e1 = new UserCategoryCreateCommand("Category Name");
// Acting on Version 0
var e2 = new UserCategoryNameChangeCommand(1, "Category Name Changed Once", 0);
// Acting on Version 1
var e3 = new UserCategoryNameChangeCommand(1, "Category Name Changed Twice", 1);
// Acting on Version 2
var e4 = new UserCategoryNameChangeCommand(1, "Category Name Changed Three Times", 2);
// Acting on Version 3
var e5 = new UserCategoryNameChangeCommand(1, "Category Name Changed Four Times", 3);
// Act
await _commandBus.Send<UserCategoryCreateCommand>(e1);
await _commandBus.Send<UserCategoryNameChangeCommand>(e2);
await _commandBus.Send<UserCategoryNameChangeCommand>(e3);
await _commandBus.Send<UserCategoryNameChangeCommand>(e4);
await _commandBus.Send<UserCategoryNameChangeCommand>(e5);
// Assert
var m = (await _mementoRepository.FindByAsync(x => x.Id == 1)).FirstOrDefault();
Assert.IsNotNull(m);
var memento = DatabaseEventStorage.DeSerialize<UserCategoryMemento>(m.Data);
UserCategory c = new UserCategory();
c.SetMemento(memento);
Assert.AreEqual("Category Name Changed Three Times", c.Name);
}
private void AddCategoryHeader(string header, UserCategory category)
{
var lstItem = new ListViewItem(header) {Tag = category};
m_iCategoryCount++;
m_lstChanges.Items.Add(lstItem);
}
private void ChangeSelectedListViewItemsToCategory(UserCategory category)
{
lock (m_lock)
{
var bChangedAnyItems = false;
foreach (ListViewItem lstItem in m_lstChanges.SelectedItems)
{
if (lstItem.Tag == null)
continue;
if (lstItem.Tag is UserCategory)
continue;
if (!(lstItem.Tag is ChangeWrapper))
continue;
var wrapper = lstItem.Tag as ChangeWrapper;
if (wrapper.Category == category)
continue;
wrapper.Category = category;
if (!bChangedAnyItems)
bChangedAnyItems = true;
}
if (bChangedAnyItems)
m_lstChanges.Sort();
}
}
private static int CompareCategoryToChangeWrapper(UserCategory cat, ChangeWrapper wrapper)
{
if (cat == wrapper.Category)
return -1;
return CompareCategories(cat, wrapper.Category);
}
private static int CompareCategories(UserCategory cat1, UserCategory cat2)
{
if (cat1 == cat2)
return 0;
return cat1 < cat2 ? -1 : 1;
}
