public virtual async Task <JsonResult> Delete(Guid id)
{
APIResultVM result = new APIResultVM();
try
{
if (id == null || id == Guid.Empty)
{
APIResult.CreateVM(false, null, AppStatusCode.WRG01001);
}
result = await _service.Delete(id);
if (Validation.ResultIsNotTrue(result))
{
return(new JsonResult(result));
}
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, result.RecId))));
}
}
public override async Task <APIResultVM> Delete(Guid id, Guid?userId = null, bool isCommit = true)
{
var group = GetById(id);
if (group == null || group.IsMain)
{
return(APIResult.CreateVM(false, id, AppStatusCode.WRG01005));
}
var result = await base.Delete(id, userId, true);
if (Validation.ResultIsNotTrue(result))
{
return(result);
}
var users = groupUserService.Repository.Query().Where(a => a.GroupId == id).Select(a => a.Id).ToList();
if (users != null)
{
foreach (var item in users)
{
await groupUserService.Delete(item, userId, true);
}
}
return(result);
}
public async Task <JsonResult> Register(UserAddVM model)
{
try
{
if (ModelState.IsValid)
{
User entity = _mapper.Map <UserAddVM, User>(model);
entity.Id = Guid.NewGuid();
entity.CreateDateTime = DateTime.UtcNow;
entity.LastLoginDateTime = DateTime.UtcNow;
var identityResult = await _userManager.CreateAsync(entity, model.PasswordHash);
if (identityResult.Succeeded)
{
await _signInManager.SignInAsync(entity, isPersistent : false);
UserAuthenticateVM returnVM = new UserAuthenticateVM();
returnVM = _mapper.Map <User, UserAuthenticateVM>(entity);
returnVM.Token = GetToken(entity);
return(new JsonResult(returnVM));
}
else
{
return(new JsonResult(APIResult.CreateVMWithRec <object>(identityResult.Errors)));
}
}
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.ERR01001)));
}
public virtual async Task <APIResultVM> ReverseDelete(Guid id, Guid?userId, bool isCommit = true)
{
try
{
Guid _userId = userId == null ? Guid.Empty : userId.Value;
D entity = await uow.Repository <D>().GetByID(id);
if (Validation.IsNull(entity))
{
return(APIResult.CreateVM(false, id, AppStatusCode.WRG01001));
}
if (entity is ITable)
{
(entity as ITable).UpdateBy = _userId;
(entity as ITable).UpdateDT = DateTime.Now;
}
entity.IsDeleted = false;
Repository.Update(entity);
if (isCommit)
{
await Commit();
}
return(APIResult.CreateVMWithRec(entity, true, entity.Id));
}
catch (Exception e)
{
return(APIResult.CreateVMWithError(e));
}
}
public virtual async Task <JsonResult> Add(A model)
{
APIResultVM result = new APIResultVM();
try
{
if (Validation.IsNull(model))
{
APIResult.CreateVM(false, null, AppStatusCode.WRG01001);
}
result = await _service.Add(model);
if (Validation.ResultIsNotTrue(result))
{
return(new JsonResult(result));
}
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, result.RecId))));
}
}
public virtual async Task <JsonResult> Add([FromBody] A model)
{
if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
var result = await _service.AddAsync(model, User.GetId());
if (result.ResultIsNotTrue())
{
return(new JsonAPIResult(result, StatusCodes.Status422UnprocessableEntity));
}
return(new JsonAPIResult(_apiResult.CreateVM(result.RecId, result.ResultIsTrue()),
StatusCodes.Status200OK));
}
public virtual JsonResult Get()
{
var result = _service.GetAll();
if (result == null)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
return(new JsonResult(result));
}
public virtual async Task <JsonResult> Add(A model)
{
var result = await _service.Add(model);
if (Validation.ResultIsNotTrue(result))
{
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
public virtual async Task <JsonResult> Delete(Guid id)
{
var result = await _service.Delete(id);
if (Validation.ResultIsNotTrue(result))
{
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
return(new JsonResult(APIResult.CreateVM(true, result.RecId)));
}
public virtual async Task <IAPIResultVM> AddAsync(A model, Guid?userId = null, bool isCommit = true)
{
try
{
Guid _userId = userId == null ? Guid.Empty : userId.Value;
D entity = _mapper.Map <A, D>(model);
if (entity.Id == null || entity.Id == Guid.Empty)
{
entity.Id = Guid.NewGuid();
}
if (entity is ITableEntity)
{
(entity as ITableEntity).CreateBy = _userId;
(entity as ITableEntity).CreateDT = DateTime.UtcNow;
}
Repository.Add(entity);
if (isCommit)
{
await CommitAsync();
}
return(_apiResult.CreateVMWithRec(entity, entity.Id, true));
}
catch (Exception e)
{
SentrySdk.CaptureException(e);
return(_apiResult.CreateVM());
}
}
public IAPIResultVM <TKey> Insert(TEntity entity, TimeSpan?expiryTime = null)
{
try
{
if (entity.Id.IsNull())
{
assignEntityId(ref entity);
}
var keyStr = System.Convert.ToString(entity.Id);
string json = JsonSerializer.Serialize(entity);
bool isSuccessful = _database.StringSet(keyStr, json, expiryTime);
return(_apiResult.CreateVMWithRec <TEntity>(entity, entity.Id, isSuccessful));
}
catch (Exception e)
{
SentrySdk.CaptureException(e);
return(_apiResult.CreateVM(entity.Id));
}
}
public virtual async Task <APIResultVM> Commit()
{
try
{
await uow.SaveChanges();
return(APIResult.CreateVM(true));
}
catch (Exception Ex)
{
throw Ex;
}
}
public virtual async Task <APIResultVM> Commit()
{
try
{
await uow.SaveChanges();
return(APIResult.CreateVM(true));
}
catch (Exception e)
{
return(APIResult.CreateVMWithError(e));
}
}
public JsonResult UserNameIsExist(string userName)
{
try
{
var result = _service.Any(userName);
return(new JsonResult(result));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
}
public async Task <JsonResult> Update([FromRoute] Guid id, [FromBody] UserUpdateVM model)
{
if (id.IsEmptyGuid())
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01003),
StatusCodes.Status400BadRequest));
}
else if (!ModelState.IsValid)
{
return(new JsonAPIResult(_apiResult.CreateVMWithModelState(modelStateDictionary: ModelState),
StatusCodes.Status400BadRequest));
}
var currentUser = await _userManager.FindByNameAsync(User.Identity.Name);
if (currentUser == null)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01004),
StatusCodes.Status404NotFound));
}
var user = await _userManager.FindByIdAsync(id.ToString());
if (user == null)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01004),
StatusCodes.Status404NotFound));
}
if (currentUser.Id != user.Id)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01007),
StatusCodes.Status403Forbidden));
}
user.About = model.About;
user.DisplayName = model.DisplayName;
IdentityResult result;
result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(new JsonAPIResult(_apiResult.CreateVMWithStatusCode(null, false, APIStatusCode.ERR01010),
StatusCodes.Status422UnprocessableEntity));
}
return(new JsonAPIResult(_apiResult.CreateVM(user.Id, true), StatusCodes.Status200OK));
}
public virtual async Task <APIResultVM> DeleteAsync(Guid id, Guid?userId = null, bool shouldBeOwner = false, bool isCommit = true)
{
try
{
Guid _userId = userId == null ? Guid.Empty : userId.Value;
D entity = await _uow.Repository <D>(_repositoryLogger).GetByIDAysnc(id);
if (entity.IsNull())
{
return(APIResult.CreateVM(false, id, new List <string>()
{
ErrorMessages.RecordNotFound
}));
}
if (shouldBeOwner && (_userId == Guid.Empty || _userId != (entity as ITableEntity).CreateBy))
{
return(APIResult.CreateVM(false, id, new List <string>()
{
ErrorMessages.NotOwnerOfRecord
}));
}
if (entity is ITableEntity)
{
(entity as ITableEntity).UpdateBy = _userId;
(entity as ITableEntity).UpdateDT = DateTime.Now;
}
entity.IsDeleted = true;
Repository.Update(entity);
if (isCommit)
{
await CommitAsync();
}
return(APIResult.CreateVMWithRec(entity, true, entity.Id));
}
catch (Exception e)
{
_logger.LogError("BaseService.DeleteAsync", e);
return(APIResult.CreateVM(messages: new List <string>()
{
"An exception occured!"
}));
}
}
public override async Task <APIResultVM> Update(Guid id, GroupUpdateVM model, Guid?userId = null, bool isCommit = true)
{
if (model.IsMain && Repository.Query().Any(a => a.Id != id && a.IsMain))
{
return(APIResult.CreateVM(false, id, AppStatusCode.WRG01005));
}
var result = await base.Update(id, model, userId, true);
if (Validation.ResultIsNotTrue(result))
{
return(result);
}
if (model.Users != null && model.Users.Count > 0)
{
foreach (var item in model.Users)
{
var groupUser = groupUserService.GetById(item);
if (groupUser == null)
{
GroupUserAddVM rec = new GroupUserAddVM();
rec.GroupId = id;
rec.UserId = item;
var userResult = await groupUserService.Add(rec, userId, true);
if (Validation.ResultIsNotTrue(userResult))
{
return(userResult);
}
}
}
}
var removedUsers = groupUserService.Repository.Query().Where(a => a.GroupId == id && (model.Users == null || !model.Users.Any(x => x == a.UserId))).Select(a => a.Id).ToList();
if (removedUsers != null)
{
foreach (var item in removedUsers)
{
await groupUserService.Delete(item, userId, true);
}
}
return(result);
}
public virtual async Task <JsonResult> Get(Guid id)
{
if (Validation.IsNullOrEmpty(id))
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01002)));
}
var result = await _service.GetByID(id);
if (result == null)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
return(new JsonResult(APIResult.CreateVMWithRec <G>(result, true, result.Id)));
}
public virtual async Task <APIResultVM> CommitAsync()
{
try
{
await _uow.SaveChanges();
return(APIResult.CreateVM(true));
}
catch (Exception e)
{
_logger.LogError("BaseService.CommitAsync", e);
return(APIResult.CreateVM(messages: new List <string>()
{
"An exception occured!"
}));
}
}
public async Task <APIResultVM> GetProfileData(Guid userId, Guid currentUserId, string sortOrder = "", int pageNumber = 1, int pageItemCount = 10, Guid?categoryId = null)
{
if (userId == null || userId == Guid.Empty)
{
APIResult.CreateVM();
}
var user = _con.Set <User>().AsNoTracking().Where(a => a.Id == userId).FirstOrDefault();
if (user == null)
{
APIResult.CreateVM();
}
ProfileVM model = new ProfileVM();
_mapper.Map <ProfileVM>(user);
model.Suggestion = new SuggestionPaggingListVM();
model.Suggestion.Pagging = new PaggingVM();
model.Suggestion.Records = _suggestionService.GetAllAsync(a => a.CreateBy == userId, true, sortOrder, pageNumber, pageItemCount, categoryId).Result;
model.Comments = await _suggestionCommentService.GetCommentsOfUser(userId);
model.Reactions = await _suggestionReactionService.GetReactionsOfUser(userId);
model.UserId = userId;
model.PictureUrl = user.PictureUrl;
model.CurrentUserId = currentUserId;
model.EMail = user.Email;
model.SuggetionCount = _con.Set <Suggestion>().Where(a => !a.IsDeleted && a.CreateBy == userId).Count();
model.Suggestion.Pagging.ActionName = "Profile";
model.Suggestion.Pagging.ControllerName = "User";
var query = _con.Set <Suggestion>().Where(a => !a.IsDeleted && a.CreateBy == userId).AsNoTracking().AsQueryable();
model.Suggestion.Pagging.IsNextPageExist = query.Skip((pageNumber * pageItemCount)).Take(1).Count() == 1;
foreach (var item in model.Suggestion.Records)
{
item.CreateByName = user.Email;
}
return(APIResult.CreateVMWithRec <ProfileVM>(model, true, userId));
}
public virtual JsonResult GetByUserId(Guid userId)
{
try
{
var result = _service.GetByUserId(userId);
if (result == null)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
return(new JsonResult(result));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
}
public JsonResult Get()
{
try
{
var result = _service.GetUserList();
if (result == null)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
return(new JsonResult(result));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
}
public async Task <JsonResult> CreateToken(UserLoginVM model)
{
var loginResult = await _signInManager.PasswordSignInAsync(model.UserName, model.PasswordHash, isPersistent : false, lockoutOnFailure : false);
if (!loginResult.Succeeded)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01004)));
}
var user = await _userManager.FindByNameAsync(model.UserName);
user.LastLoginDateTime = DateTime.UtcNow;
await _userManager.UpdateAsync(user);
UserAuthenticateVM returnVM = new UserAuthenticateVM();
returnVM = _mapper.Map <User, UserAuthenticateVM>(user);
returnVM.Token = GetToken(user);
return(new JsonResult(returnVM));
}
public async Task <JsonResult> Update(UserUpdateVM model)
{
try
{
var user = await _userManager.FindByIdAsync(model.Id.ToString());
if (user != null)
{
user.About = model.About;
user.DisplayName = model.DisplayName;
user.IsAdmin = model.IsAdmin;
user.UserName = model.UserName;
IdentityResult result;
if (model.OldPassword != model.PasswordHash)
{
result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.PasswordHash);
if (!result.Succeeded)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
}
result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
}
return(new JsonResult(APIResult.CreateVM(true, user.Id)));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
}
public virtual async Task <APIResultVM> Update(Guid id, U model, Guid?userId = null, bool isCommit = true)
{
try
{
Guid _userId = userId == null ? Guid.Empty : userId.Value;
if (model.Id == null || model.Id == Guid.Empty)
{
model.Id = Guid.NewGuid();
}
D entity = await uow.Repository <D>().GetByID(model.Id);
if (Validation.IsNull(entity))
{
APIResult.CreateVM(false, id, AppStatusCode.WRG01001);
}
entity = mapper.Map <U, D>(model, entity);
if (entity is ITable)
{
(entity as ITable).UpdateBy = _userId;
(entity as ITable).UpdateDT = DateTime.Now;
}
uow.Repository <D>().Update(entity);
if (isCommit)
{
await Commit();
}
return(APIResult.CreateVMWithRec(entity, true, entity.Id));
}
catch (Exception e)
{
throw e;
}
}
public JsonResult GetById(Guid id)
{
try
{
if (Validation.IsNullOrEmpty(id))
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01002)));
}
var result = _service.GetById(id);
if (result == null)
{
return(new JsonResult(APIResult.CreateVM(false, null, AppStatusCode.WRG01001)));
}
return(new JsonResult(APIResult.CreateVMWithRec <User>(result, true, result.Id)));
}
catch (Exception ex)
{
return(new JsonResult(APIResult.CreateVMWithError(ex, APIResult.CreateVM(false, null, AppStatusCode.ERR01001))));
}
}
public virtual async Task <APIResultVM> AddAsync(S model, Guid?userId = null, bool isCommit = true)
{
try
{
Guid _userId = userId == null ? Guid.Empty : userId.Value;
D entity = _mapper.Map <S, D>(model);
if (entity.Id == null || entity.Id == Guid.Empty)
{
entity.Id = Guid.NewGuid();
}
if (entity is ITableEntity)
{
(entity as ITableEntity).CreateBy = _userId;
(entity as ITableEntity).CreateDT = DateTime.Now;
}
Repository.Add(entity);
if (isCommit)
{
await CommitAsync();
}
return(APIResult.CreateVMWithRec(entity, true, entity.Id));
}
catch (Exception e)
{
_logger.LogError("BaseService.AddAsync", e);
return(APIResult.CreateVM(messages: new List <string>()
{
"An exception occured!"
}));
}
}
