public bool DeleteNotice(int id)
{
NoticeBoard notice = new NoticeBoard();
try
{ notice = _data.Notice.FirstOrDefault(x => (x.Id == id));
if ((notice.CreatorId == Current_User_id) || (HttpContext.Current.User.IsInRole(UserRole.Administrator.ToString())))
{
var comment = _data.PublicComments.Where(x => x.NoticeId == id);
_data.PublicComments.RemoveRange(comment);
_data.Notice.Remove(notice);
_data.SaveChanges();
return(true);
}
else
{
return(false);
} }
catch
{
return(false);
}
}
public IEnumerable <NoticeBoardViewModel> LatestNotice(int length)
{
List <NoticeBoardViewModel> noticeList = new List <NoticeBoardViewModel>();
try
{
var orderedNotices = _data.Notice.Where(x => x.IsApproved).OrderBy(x => x.PinUp)
.ThenByDescending(x => x.SubmitDate).Take(length);
foreach (var n in orderedNotices)
{
var nvm = new NoticeBoardViewModel();
var noticeBoard = new NoticeBoard();
noticeBoard.UniqueUrl = n.UniqueUrl;
noticeBoard.SubmitDate = n.SubmitDate;
noticeBoard.Description = n.Description;
noticeBoard.Title = n.Title;
nvm.Notice = noticeBoard;
nvm.TotalComments = _noticeManager.GetComments(n.Id).Count();
nvm.NoticeImage = _noticeManager.GetNoticeImage(n.Id, "Notice");
nvm.PostedBy = n.Creator.UserName.UserName();
noticeList.Add(nvm);
}
}
catch (Exception ex)
{
//log the exception.
}
return(noticeList);
}
internal bool AddNoticeBoard(NoticeBoard model)
{
bool result = false;
try
{
string query = "INSERT INTO noticeboard (title, description, datetime) VALUES(@title, @description, @datetime)";
SqlCommand cmd = new SqlCommand(query, Conn);
cmd.Parameters.Add(new SqlParameter("title", model.Title));
cmd.Parameters.Add(new SqlParameter("description", model.Description));
cmd.Parameters.Add(new SqlParameter("datetime", model.Date));
Conn.Open();
int rows = cmd.ExecuteNonQuery();
if (rows > 0)
{
result = true;
}
}
catch (Exception exp)
{
}
finally
{
Conn.Close();
}
return(result);
}
public async Task <IActionResult> WriteBoard([FromBody] AttachableBoardModel boardModel)
{
using (var session = _accountContext.SessionFactory.OpenSession())
using (var trans = session.BeginTransaction())
{
NoticeBoard NewBoard = new NoticeBoard();
NewBoard.RegisterUserId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
NewBoard.Title = boardModel.Title;
NewBoard.Contents = boardModel.Contents;
NewBoard.Createts = DateTime.Now;
await session.SaveOrUpdateAsync(NewBoard);
if (boardModel.AttachFiles.Length > 0)
{
foreach (AttachFileModel attach in boardModel.AttachFiles)
{
AttachFileRepositary attachFile = RegisterFile(0, NewBoard.ID, attach.Filename, attach.ContentsBase64);
await session.SaveOrUpdateAsync(attachFile);
}
}
await trans.CommitAsync();
}
return(Ok());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Time,Description,IsDeleted,TimeDeleted")] NoticeBoard noticeBoard)
{
if (id != noticeBoard.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(noticeBoard);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NoticeBoardExists(noticeBoard.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(noticeBoard));
}
public ActionResult PublishNotice(NoticeBoard notice)
{
notice.FileName = Path.GetFileNameWithoutExtension(notice.Files.FileName);
notice.FilePath = notice.FileName + System.IO.Path.GetExtension(notice.Files.FileName);
string fileName = "~/NoticeFiles/" + notice.FileName + System.IO.Path.GetExtension(notice.Files.FileName);
notice.Files.SaveAs(Server.MapPath(fileName));
try
{
if (ModelState.IsValid)
{
if (notice.publishNotice())
{
ViewBag.Message = "Publish successfully";
ModelState.Clear();
}
else
{
ViewBag.Message = "Sorry! try again.";
}
return(View());
}
return(View());
}
catch
{
return(View());
}
}
public async Task <IActionResult> Create(NoticeBoard noticeBoard)
{
if (!ModelState.IsValid)
{
return(View());
}
if (noticeBoard.Title != null)
{
bool IsValid = _db.NoticeBoards.Any(c => c.Title.ToLower() == noticeBoard.Title.ToLower());
if (IsValid)
{
ModelState.AddModelError("Title", "Bu Basliq artiq var");
return(View());
}
}
bool IsValidDes = _db.NoticeBoards.Any(c => c.Description.ToLower() == noticeBoard.Description.ToLower());
if (IsValidDes)
{
ModelState.AddModelError("Description", "Bu Description artiq var");
return(View());
}
await _db.NoticeBoards.AddAsync(noticeBoard);
await _db.SaveChangesAsync();
return(RedirectToAction("index"));
}
public async Task <NoticeBoard> PostNoticeBoard(NoticeBoard item)
{
_context.NoticeBoards.Add(item);
await _context.SaveChangesAsync();
return(item);
}
public NoticeBoard PostNotices(NoticeBoard model)
{
try
{
model.IsApproved = true;
model.SubmitDate = DateTime.Now;
model.CreatorId = model.CreatorId;
model.ActionDate = DateTime.Now;
model.Description = model.Description.Replace(System.Environment.NewLine, "<br/>");
if (model.PinUp)
{
var PreviousPinUpNotice = _data.Notice.FirstOrDefault(x => (x.PinUp == true));
if (PreviousPinUpNotice != null)
{
PreviousPinUpNotice.PinUp = false;
_data.Entry(PreviousPinUpNotice).State = EntityState.Modified;
}
}
_data.Notice.Add(model);
_data.SaveChanges();
model.UniqueUrl = $"{model.Id}-{model.Title.Replace(" ", "-")}";
_data.SaveChanges();
return(model);
}
catch
{
throw;
}
}
public FileResult DownloadFile(int id, NoticeBoard obj)
{
obj.GetFiles(id);
string filepath = Server.MapPath("~/NoticeFiles/" + obj.FilePath);
return(File(filepath, "application/pdf", obj.FileName + ".pdf"));
}
public ActionResult DeleteConfirmed(int id)
{
NoticeBoard noticeboard = db.NoticeBoards.Find(id);
db.NoticeBoards.Remove(noticeboard);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(NoticeBoard model)
{
try
{
model.CreatorId = User.Identity.GetUserId();
var notice = _noticeBoardManager.PostNotices(model);
if (Request.Files.Count > 0)
{
var file = Request.Files[0];
if (file != null && file.ContentLength > 0)
{
var fileName = Guid.NewGuid() + "_" + Path.GetFileName(file.FileName);
var path = Path.Combine(Server.MapPath("~/Content/images/"), fileName);
file.SaveAs(path);
var image = new SiteImage
{
ImagePath = "/Content/images/" + fileName,
Type = "Notice",
TypeId = notice.Id,
UploadDate = DateTime.Now,
UploaderId = notice.CreatorId
};
_noticeBoardManager.SaveImage(image);
}
else
{
var image = new SiteImage
{
ImagePath = "/Content/images/Event/defaultNotice.png",
Type = "Notice",
TypeId = notice.Id,
UploadDate = DateTime.Now,
UploaderId = notice.CreatorId
};
_noticeBoardManager.SaveImage(image);
}
}
}
catch (Exception ex)
{
logger.Error($"Error creating notice. {ex}");
Email_Service_Model email = new Email_Service_Model();
email.ToEmail = System.Configuration.ConfigurationManager.AppSettings["BccEmail"];
email.EmailSubject = $"Failed to create notice. User- {model.Creator.UserName}";
email.EMailBody = $"Description: {model.Description}. Title: {model.Title}. Exception: {ex.ToString()}";
var emailmanager = new UtilityManager();
emailmanager.SendEmail(email);
}
return(RedirectToAction("Index"));
}
public async Task UpdateNoticeBoard(NoticeBoard noticeBoard)
{
if (_context != null)
{
_context.NoticeBoard.Update(noticeBoard);
await _context.SaveChangesAsync();
}
}
public void ActiveInactiveNotice(int noticeId, bool IsActive)
{
NoticeBoard existing = this._noticeBoardRepo.GetById(noticeId);
if (existing != null)
{
existing.IsActive = IsActive;
this._noticeBoardRepo.Update(existing);
}
}
public async Task <IActionResult> Undo()
{
NoticeBoard notice = _db.NoticeBoards.OrderByDescending(n => n.Id).FirstOrDefault(n => n.PostedBy == User.Identity.Name);
string desc = notice.Description;
_db.NoticeBoards.Remove(notice);
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Notice", new { nb = desc }));
}
//
// GET: /NoticeBoard/Delete/5
public ActionResult Delete(int id = 0)
{
NoticeBoard noticeboard = db.NoticeBoards.Find(id);
if (noticeboard == null)
{
return(HttpNotFound());
}
return(View(noticeboard));
}
protected override void Awake()
{
base.Awake();
NoticeBoard <CamShakeParams> .Watch(note_shake, Shake);
NoticeBoard.Watch(note_shake_small, ShakeSmall);
NoticeBoard.Watch(note_shake_med, ShakeMed);
NoticeBoard.Watch(note_shake_big, ShakeBig);
}
public ActionResult Edit(NoticeBoard noticeboard)
{
if (ModelState.IsValid)
{
db.Entry(noticeboard).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(noticeboard));
}
public static BoardViewModel From(NoticeBoard noticeBoard)
{
return(new BoardViewModel
{
Id = noticeBoard.NoticeBoardId,
Title = noticeBoard.Title,
Description = noticeBoard.Description,
IsOfficial = noticeBoard.IsOfficial,
IsMandatory = noticeBoard.IsMandatory
});
}
public async Task <IActionResult> Create([Bind("Id,Title,Time,Description,IsDeleted,TimeDeleted")] NoticeBoard noticeBoard)
{
if (ModelState.IsValid)
{
_context.Add(noticeBoard);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(noticeBoard));
}
public ActionResult Create(NoticeBoard noticeboard)
{
if (ModelState.IsValid)
{
db.NoticeBoards.Add(noticeboard);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(noticeboard));
}
//
// GET: /NoticeBoard/Details/5
public ActionResult Details(int id = 0)
{
//NoticeBoard noticeboard = db.NoticeBoards.Find(id);
NoticeBoard noticeboard = db.NoticeBoards.Include("notes").Single(n => n.boardId == id);
if (noticeboard == null)
{
return(HttpNotFound());
}
return(View(noticeboard));
}
public static NoticeBoardIndexViewModel ToNoticeBoardIndexViewModel(NoticeBoard nb)
{
var vm = new NoticeBoardIndexViewModel
{
Id = nb.NoticeBoardId,
Title = nb.Title,
Description = nb.Description
};
return(vm);
}
public ActionResult ViewNotice(NoticeBoard notice)
{
if (Request.Cookies.Get("admin") != null)
{
notice.Data = notice.viewNotices();
return(View(notice));
}
else
{
return(RedirectToAction("ERP", "ERP"));
}
}
public async Task <bool> Insert(NoticeModel model)
{
var notice = new NoticeBoard {
Name = model.Name, NoticeDateTime = model.NoticeDateTime, Description = model.Description
};
_context.NoticeBoards.Add(notice);
await _context.SaveChangesAsync();
return(true);
}
public static NoticeBoard From(NoticeBoardEditViewModel vm)
{
NoticeBoard noticeBoard = new NoticeBoard
{
NoticeBoardId = vm.Id,
Title = vm.Title,
Description = vm.Description,
IsMandatory = vm.IsMandatory
};
return(noticeBoard);
}
public static NoticeBoardEditViewModel ToNoticeBoardEditViewModel(NoticeBoard nb)
{
NoticeBoardEditViewModel vm = new NoticeBoardEditViewModel
{
Id = nb.NoticeBoardId,
Title = nb.Title,
Description = nb.Description,
IsMandatory = nb.IsMandatory
};
return(vm);
}
public async Task <IActionResult> Create(NoticeBoard _board)
{
NoticeBoard board = new NoticeBoard
{
Content = _board.Content,
Date = DateTime.Now
};
_db.NoticeBoards.Add(board);
await _db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <int> AddNoticeBoard(NoticeBoard noticeBoard)
{
if (_context != null)
{
await _context.NoticeBoard.AddAsync(noticeBoard);
await _context.SaveChangesAsync();
return(noticeBoard.Id);
}
return(0);
}
public static void Enter(Player player)
{
Interface.BasicInterfaceDelegate(player, LineHelpers.PrintLineWithContinue, "The town is vibrant and people are walking around and trading freely but you sense an air of worry.");
while (true)
{
// A simple switch to check what the player wants to do. this could and probably should be just a while loop
Interface.BasicInterfaceDelegateParams(player, LineHelpers.PrintLine, "Town:", "1. Head West", "2. Enter Inn", "3. Enter Shop.", "4. Check Notice Board", "5. Character Sheet", "6. View Inventory", "7. Save and Quit Game");
int type = LineHelpers.ReadInputNumber(new int[] { 1, 2, 3, 4, 5, 6, 7 });
Interface.BasicInterface(player);
// This is like the game hub and the player can only save here.
switch (type)
{
case 1:
Dungeon.Enter(player);
break;
case 2:
Inn.Enter(player);
break;
case 3:
Shop.Enter(player);
break;
case 4:
NoticeBoard.Check(player);
break;
case 5:
Sheets.Character(player);
break;
case 6:
player.ViewInventory();
break;
default:
if (Game.Save(player))
{
return;
}
break;
}
}
}
