public ActionResult ForgotPassword(Users model)
{
string _kod;
string url;
var modeluser = _uow.GetRepo <Users>().Where(x => x.Email == model.Email).FirstOrDefault();
if (modeluser != null)
{
_kod = Guid.NewGuid().ToString();
url = Path.Combine("http://localhost:1403/Login/PasswordConfirm", "?kod=" + _kod);
modeluser.Code = _kod;
_uow.GetRepo <Users>().Update(modeluser);
if (_uow.Commit() > 0)
{
string msgString = "<a href=" + url + ">Parolamı değiştir</a>";
var msg = (MessageService)_msgService;
msg.To = model.Email;
bool Ok = msg.SendMessage("Subject", msgString);
if (Ok)
{
ViewBag.Msg = "Mail adresinize parola sıfırlama linki gönderilmiştir.";
return(View());
}
}
}
return(View());
}
public ActionResult PostAdd(PostViewModel model)
{
var validator = new PostAddValidator(_uow).Validate(model.Post);
if (validator.IsValid)
{
if (model.PostedPicture != null)
{
string dosyaYolu = Path.GetFileName(model.PostedPicture.FileName);
var yuklemeYeri = Path.Combine(Server.MapPath("~/Images"), dosyaYolu);
model.PostedPicture.SaveAs(yuklemeYeri);
model.Post.PostPic = dosyaYolu;
}
model.Post.PostDate = DateTime.Now;
model.Post.LikeCount = 0;
model.Post.DislikeCount = 0;
model.Post.UserId = 1;
_uow.GetRepo <Post>().Add(model.Post);
var cat = _uow.GetRepo <Category>().GetById(model.Post.CategoryId);
cat.PostCount = cat.PostCount + 1;
_uow.GetRepo <Category>().Update(cat);
_uow.Commit();
ViewBag.Msg = "Gönderi başarılı bir şekilde kaydedildi";
return(RedirectToAction("Post", "Post"));
}
else
{
validator.Errors.ToList().ForEach(x => ModelState.AddModelError(x.PropertyName, x.ErrorMessage));
}
ViewBag.Msg = "İşlem gerçekleştirilemedi";
return(View());
}
/// <summary>
/// 添加用户
/// </summary>
/// <param name="sysUser"></param>
/// <returns></returns>
public async Task <bool> AddUser(SysUser sysUser)
{
sysUser.Id = Guid.NewGuid();
var str = sysUser.RoleIds;
var RoleIds = JsonConvert.DeserializeObject <List <Guid> >(sysUser.RoleIds);
var Rolelist = new List <SysUserRole>();
Rolelist.AddRange(RoleIds.Select(x => new SysUserRole
{
RoleId = x,
CreatedId = sysUser.CreatedId,
CreatedName = sysUser.CreatedName,
UserIdOrDepId = sysUser.Id,
}));
try
{
_unitofWork.BeginTransaction();
await _userRepositoty.InsertAsync(sysUser);
await _userRoleRepository.InsertAsync(Rolelist);
_unitofWork.Commit();
return(true);
}
catch (Exception)
{
throw;
}
}
public void AddClassType(ClassType myClass)
{
classRepository.Add(myClass);
//transform the object
unitofWork.Commit();
}
public object Commit(object objeto = null)
{
if (_notifications.temNotificacoes())
{
return(null);
}
return(_unitOfWork.Commit(objeto));
// return true;
}
public IActionResult CreateLetter(Letter letter)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
unitOfWork.Letters.Add(letter);
unitOfWork.Commit();
return(Created(new Uri("api/letters/" + letter.Id), letter));
}
public async Task <ActionResult> Alterar(int id, [FromBody] ProdutoDto produtoDto)
{
if (id != produtoDto.ProdutoId)
{
return(BadRequest());
}
var produto = _mapper.Map <Produto>(produtoDto);
_uof.ProdutoRepository.Update(produto);
await _uof.Commit();
return(Ok(produtoDto));
}
public async Task <IActionResult> PutCategoria(int id, CategoriaDto categoriaDto)
{
if (id != categoriaDto.CategoriaId)
{
return(BadRequest($"Não foi possivel atualizar a categoria com id={id}"));
}
var categoria = _mapper.Map <Categoria>(categoriaDto);
_uof.CategoriaRepository.Update(categoria);
await _uof.Commit();
return(Ok(categoriaDto));
}
public IActionResult PutCategoria(int id, CategoriaDTO categoriaDto)
{
if (id != categoriaDto.CategoriaId)
{
return(BadRequest());
}
var categoria = _mapper.Map <Categoria>(categoriaDto);
_context.CategoriaRepository.Update(categoria);
_context.Commit();
return(NoContent());
}
public IActionResult PutProduto(int id, [FromBody] ProdutoDTO produtoDto)
{
if (id != produtoDto.ProdutoId)
{
return(BadRequest());
}
var produto = _mapper.Map <Produto>(produtoDto);
_uof.ProdutoRepositoy.Update(produto);
_uof.Commit();
return(NoContent());
}
//public virtual IEnumerable<TDto> MapToDtoList<TEntity, TDto>(IEnumerable<TEntity> entity)
//where TEntity : class
//where TDto : class
//{
// Mapper mapper;
// mapper.cre.CreateMap<TEntity, TDto>();
// return Mapper.Map<IEnumerable<TEntity>, IEnumerable<TDto>>(entity);
//}
//public virtual IEnumerable<TEntity> MapToEntityList<TDto, TEntity>(IEnumerable<TDto> dto)
// where TDto : class
// where TEntity : class
//{
// Mapper.CreateMap<TDto, TEntity>();
// return Mapper.Map<IEnumerable<TDto>, IEnumerable<TEntity>>(dto);
//}
public async Task <TOUT> CreateAsync(TOUT entity_out)
{
try
{
var entidad = _mapper.Map <TIN>(entity_out);
await _unitofWork._context.Set <TIN>().AddAsync(entidad);
_unitofWork.Commit();
return(_mapper.Map <TOUT>(entidad));
}
catch (Exception)
{
throw new NotImplementedException();
}
}
public async Task <bool> SaveRoleByUser(UpdateUserRoleVo updateUserRole)
{
try
{
var RoleIds = new List <Guid>();
if (!updateUserRole.RoleIds.IsNullOrEmpty())
{
RoleIds.AddRange(JsonConvert.DeserializeObject <List <Guid> >(updateUserRole.RoleIds));
}
var Rolelist = new List <SysUserRole>();
var deletelist = await _userRoleRepository.GetAllListAsync(x => x.UserIdOrDepId == updateUserRole.userId);
Rolelist.AddRange(RoleIds.Select(x => new SysUserRole
{
RoleId = x,
CreatedId = updateUserRole.CreateId,
CreatedName = updateUserRole.CreateName,
UserIdOrDepId = updateUserRole.userId,
}));
_unitofWork.BeginTransaction();
await _userRoleRepository.Delete(deletelist);
await _userRoleRepository.InsertAsync(Rolelist);
_unitofWork.Commit();
return(true);
}
catch (Exception)
{
throw;
}
}
public JsonResult Yorum(string Yorum, int postid)
{
CommentViewModel model = new CommentViewModel();
model.CommentBody = Yorum;
model.CommentDate = DateTime.Now.ToShortDateString();
model.UserId = 1;
model.PostId = postid;
Comments c = new Comments();
c.PostCommend = model.CommentBody;
c.CommendDate = DateTime.Now;
c.UserId = 1;
c.IsDeleted = false;
c.LikeCount = 0;
c.DislikeCount = 0;
c.PostId = model.PostId;
_uow.GetRepo <Comments>().Add(c);
_uow.Commit();
return(Json(model));
}
public async Task <IActionResult> Create([FromBody] PositionDTO positionDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var position = Mapper.Map <PositionDTO, Position>(positionDTO);
await _unitofWork.PositionRepository.AddAsync(position);
await _unitofWork.Commit();
position = await _unitofWork.PositionRepository.SingleOrDefault(p => p.Id == position.Id);
return(Ok(Mapper.Map <Position, PositionDTO>(position)));
}
public async Task <IActionResult> Create([FromBody] LevelSectionDTO LevelSectionDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var levelSection = Mapper.Map <LevelSectionDTO, LevelSection>(LevelSectionDTO);
await _unitofWork.LevelSectionRepository.AddAsync(levelSection);
await _unitofWork.Commit();
levelSection = await _unitofWork.LevelSectionRepository.SingleOrDefault(p => p.Id == levelSection.Id);
return(Ok(Mapper.Map <LevelSection, LevelSectionDTO>(levelSection)));
}
public async Task <IActionResult> Create([FromBody] SectionAdviser01DTO sectionAdviser01DTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var sectionAdviser = Mapper.Map <SectionAdviser01DTO, SectionAdviser>(sectionAdviser01DTO);
await _unitofWork.SectionAdviserRepository.AddAsync(sectionAdviser);
await _unitofWork.Commit();
sectionAdviser = await _unitofWork.SectionAdviserRepository.SingleOrDefault(p => p.Id == sectionAdviser.Id);
return(Ok(Mapper.Map <SectionAdviser, SectionAdviser01DTO>(sectionAdviser)));
}
public ActionResult CategoryUpdate(Category model)
{
var validator = new CategoryUpdateValidator(_uow).Validate(model);
if (validator.IsValid)
{
_uow.GetRepo <Category>().Update(model);
if (_uow.Commit() > 0)
{
ViewBag.Msg = "Başarıyla kaydedildi.";
return(RedirectToAction("Category", "Category"));
}
return(View());
}
else
{
validator.Errors.ToList().ForEach(x => ModelState.AddModelError(x.PropertyName, x.ErrorMessage));
}
return(View());
}
/// <summary>
/// 新增管理员组
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public int InsertGroup(string name, Array roles)
{
var RGroup = RGroupRep.Get(null, "", x => x.OrderByDescending(y => y.RG_no)).FirstOrDefault();
int RGid = 1;
if (RGroup != null)
{
RGid = RGroup.RG_no + 1;
}
RGroupRep.Insert(new RoleGroup {
RG_no = RGid, RG_name = name
});
foreach (var rid in roles)
{
contactRep.Insert(new RoleContact()
{
RG_no = RGid, R_no = Convert.ToInt32(rid)
});
}
return(unit.Commit());
}
/// <summary>
/// 保存权限方法
/// </summary>
/// <param name="saveRoleAssigView"></param>
/// <returns></returns>
public async Task <bool> SaveRoleAssig(SaveRoleAssigViewModel saveRoleAssigView)
{
List <Guid> BtnIdlist = new List <Guid>();
BtnIdlist.AddRange(JsonConvert.DeserializeObject <List <Guid> >(saveRoleAssigView.BtnIds));//获取选中的按钮ID
List <RoleAssigMenuViewModel> roleAssigMenuViews = new List <RoleAssigMenuViewModel>();
roleAssigMenuViews.AddRange(JsonConvert.DeserializeObject <List <RoleAssigMenuViewModel> >(saveRoleAssigView.menuIds));//获取选中的按钮ID
try
{
var sysButtonlist = await _buttonRepositoty.GetAllListAsync(x => BtnIdlist.Contains(x.Id));//根据按钮ID获取所有的按钮及对应的菜单
var DeleteroleRight = await _roleRightAssigRepository.GetAllListAsync(x => x.RoleId == saveRoleAssigView.RoleId);
List <SysRoleRight> SysRoleRightList = new List <SysRoleRight>();
var menuIds = sysButtonlist.Select(x => new { x.MenuId }).Distinct().ToList(); //根据按钮ID获取所有的按钮及对应的菜单,并且根据菜单ID去重
foreach (var item in menuIds) //将去重的菜单ID添加到角色权限List容器中
{
SysRoleRightList.Add(new SysRoleRight {
MenuId = item.MenuId,
RoleId = saveRoleAssigView.RoleId,
CreatedId = saveRoleAssigView.CreatedId,
CreatedName = saveRoleAssigView.CreatedName,
});
}
var ReadMenulist = SysRoleRightList.ToSelectList(x => x.MenuId);
var MenuList = roleAssigMenuViews.Where(x => !ReadMenulist.Contains(x.Id)).ToList(); //获取到还未选中的菜单
SysRoleRightList.AddRange(MenuList.Select(x => new SysRoleRight //将未选中的菜单添加到角色权限对象中
{
MenuId = x.Id,
RoleId = saveRoleAssigView.RoleId,
CreatedId = saveRoleAssigView.CreatedId,
CreatedName = saveRoleAssigView.CreatedName,
}).ToList());
SysRoleRightList.ForEach(item =>//根据菜单ID获取菜单下面所有的按钮
{
var BtnList = sysButtonlist.Where(x => x.MenuId == item.MenuId).ToList();
item.ButtonIds = string.Join(",", BtnList.Select(x => x.Id));
});
_unitofWork.BeginTransaction();
await _roleRightAssigRepository.Delete(DeleteroleRight);
await _roleRightAssigRepository.InsertAsync(SysRoleRightList);
_unitofWork.Commit();
return(true);
}
catch (Exception ex)
{
throw new Exception($"Commit 异常：{ex.InnerException}/r{ ex.Message}");
}
}
public bool Commit()
{
if (Notifications.HasNotifications())
{
return(false);
}
if (UnitOfWork.Commit())
{
return(true);
}
Bus.RaiseEvent(new DomainNotification("Commit", "We had a problem during saving your data."));
return(false);
}
public void Save()
{
using (_unitofWork)
{
var user = new SysUser()
{
Id = Guid.NewGuid(),
CreateTime = DateTime.Now,
IsDelete = false,
};
_userRepository.Insert(user);
_unitofWork.Commit();
}
}
//[CustomAuthorize(Role = "Admin")]
public IActionResult AddProduct([FromBody] FlightDetailsVM flightToInsert)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_logger.LogError("Error Logging: Flight Info=" + flightToInsert.FlightId);
var flight = _mapper.Map <Flight>(flightToInsert);
uow.FlightDetailsRepo.Add(flight);
uow.Commit();
InsertResult result = new InsertResult()
{
NewId = flight.FlightId,
Message = "Flight added"
};
return(StatusCode(201, result));
}
public async Task <Payment> CreateOrUpdatePayment(PaymentDto paymentDto)
{
try
{
await _unitofWork.PaymentRepository.CreateOrUpdatePayment(paymentDto);
_unitofWork.Commit();
return(null);
}
catch (Exception e)
{
_unitofWork.Rollback();
return(null);
}
}
public async Task <Orders> CreateOrderAsync(OrderDto orderDto)
{
try
{
await _unitofWork.OrderRepository.CreateOrderAsync(orderDto);
_unitofWork.Commit();
sendMail(orderDto);
return(null);
}
catch (Exception e)
{
_unitofWork.Rollback();
return(null);
}
}
//[CustomAuthorize(Role = "User")]
public IActionResult FlightBook(Flight_Book book)
{
if (!ModelState.IsValid)
{
return BadRequest();
}
if (uow.FlightBookingRepo.CheckFlight(book.DateOfJourney, book.FlightId))
{
uow.FlightBookingRepo.Add(book);
uow.Commit();
}
else
{
return Ok(new InsertResult() { NewId = book.BookId, Message = "Flights are not available" });
}
return Ok(new InsertResult() { NewId = book.BookId, Message = "Flight booked successfully" });
}
public ActionResult Register(Users model)
{
var valid = new UsersRegisterValidator(_uow).Validate(model);
if (valid.IsValid)
{
model.RoleId = 2;
_uow.GetRepo <Users>().Add(model);
_uow.Commit();
return(RedirectToAction("Home", "SiteHome"));
}
else
{
valid.Errors.ToList().ForEach(x => ModelState.AddModelError(x.PropertyName, x.ErrorMessage));
}
return(View());
}
public ActionResult Insert(EPostDTO post)
{
try
{
_uow.BeginTransaction();
post.Slug = _postService.GetSlugAnyPost(StringManager.ToSlug(post.Title));
post.UserId = ((SessionContext)Session["SessionContext"]).Id;
post.PostContent = HttpUtility.HtmlEncode(post.PostContent);
if (Session["TempImage"] != null)
{
post.Image = (byte[])Session["TempImage"];
}
_postService.Insert(post);
_uow.SaveChanges();
_uow.Commit();
return(Json(true, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
_uow.Rollback();
return(Json(false, JsonRequestBehavior.AllowGet));
}
}
public void AddReservation(Reservation myReservation)
{
reservationRepository.Add(myReservation);
unitofWork.Commit();
}
/// <summary>
///
/// </summary>
/// <param name="objUserLogin"></param>
public void InsertUserLogin(UserLogin objUserLogin)
{
_userLoginRepository.Add(objUserLogin);
_unitOfWork.Commit();
}
/// <summary>
///
/// </summary>
/// <param name="objRole"></param>
public void InsertRole(Role objRole)
{
_roleRepository.Add(objRole);
_unitOfWork.Commit();
}
