public async Task <ActionResult> Edit(int?id)
{
try
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var entity = await db.Penalties.FindAsync(id);
if (entity == null)
{
return(HttpNotFound());
}
var model = new PenaltyModel
{
PayRate = entity.PayRate,
From = entity.From,
To = entity.To,
PenaltyFee = entity.PenaltyFee,
};
return(View(model));
}
catch (Exception e)
{
AddAlert($"Oops! something went wrong. Error code: {e.HResult}", "Edit", this.GetType().ToString(), AlertType.error, e);
return(View(new ProjectModel()));
}
}
public async Task <ActionResult> Create(PenaltyModel model)
{
try
{
if (ModelState.IsValid)
{
var entity = new Penalty
{
PayRate = model.PayRate,
From = model.From,
To = model.To,
PenaltyFee = model.PenaltyFee,
LastUpdate = DateTime.Now,
CreationDate = DateTime.Now,
IsDeleted = false,
};
db.Penalties.Add(entity);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
catch (Exception e)
{
AddAlert($"Oops! something went wrong. Error code: {e.HResult}", "Create(model)", this.GetType().ToString(), AlertType.error, e);
}
return(View(model));
}
public async Task <ActionResult> Edit(PenaltyModel model)
{
try
{
if (ModelState.IsValid)
{
var entity = await db.Penalties.FindAsync(model.Id);
if (entity == null)
{
return(HttpNotFound());
}
entity.PayRate = model.PayRate;
entity.From = model.From;
entity.To = model.To;
entity.PenaltyFee = model.PenaltyFee;
entity.LastUpdate = DateTime.Now;
db.Entry(entity).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(model));
}
catch (Exception e)
{
AddAlert($"Oops! something went wrong. Error code: {e.HResult}", "Edit(model)", this.GetType().ToString(), AlertType.error, e);
return(View(model));
}
}
private IList <PenaltyModel> ProcessPenaltySheetPlayer(ExcelRange penalties, int rowOffset, bool isFirstHalf)
{
List <PenaltyModel> list = new List <PenaltyModel>();
int columnOffset = 2;
while (columnOffset < 10)
{
// go through each foul
object foulTypeObj = penalties.SubRange(rowOffset, columnOffset).Value;
if (foulTypeObj == null || string.IsNullOrWhiteSpace(foulTypeObj.ToString()))
{
columnOffset++;
continue;
}
string foulType = foulTypeObj.ToString().Trim();
char? specialKey = null;
if (foulType.Length > 1)
{
specialKey = foulType[1];
foulType = foulType.Substring(0, 1);
}
int jamNumber = Convert.ToInt32(penalties.SubRange(rowOffset + 1, columnOffset).Value);
PenaltyModel penalty = new PenaltyModel
{
IsFirstHalf = isFirstHalf,
JamNumber = jamNumber,
PenaltyCode = foulType,
SpecificKey = specialKey
};
list.Add(penalty);
columnOffset++;
}
return(list);
}
public ActionResult Index()
{
var data = _penaltyBLL.GetPenalty();
var model = new PenaltyModel();
model.Details = Mapper.Map <List <PenaltyItem> >(data);
foreach (var item in model.Details)
{
var Vendor = _vendorBLL.GetByID(item.Vendor);
if (Vendor != null)
{
item.VendorName = Vendor.VendorName;
}
}
model.MainMenu = _mainMenu;
model.CurrentLogin = CurrentUser;
model.CurrentPageAccess = CurrentPageAccess;
if (CurrentUser.UserRole == Enums.UserRole.Viewer)
{
model.IsShowNewButton = false;
model.IsNotViewer = false;
}
else
{
model.IsShowNewButton = true;
model.IsNotViewer = true;
}
return(View(model));
}
public HttpResponseMessage Save(PenaltyModel model)
{
try
{
if (this.ModelState.IsValid)
{
var PenaltyList = service.SavePenalty(model);
if (PenaltyList != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, PenaltyList));
}
else
{
string message = "Error Saving Data";
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, message));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.InnerException.Message));
}
}
public ActionResult Upload()
{
var model = new PenaltyModel();
model.MainMenu = _mainMenu;
model.CurrentLogin = CurrentUser;
return(View(model));
}
public async Task AddPenalty(PenaltyModel model)
{
using (HttpResponseMessage response = await _apiHelper.ApiClient.PostAsJsonAsync("/api/penalty/AddPenalty", model))
{
if (response.IsSuccessStatusCode == false)
{
throw new Exception(response.ReasonPhrase);
}
}
}
public async Task <PenaltyDto> CreateAsync(int creatorId, PenaltyDto dto)
{
dto.CreatorId = creatorId;
dto.Date = DateTime.Now;
PenaltyModel model = _mapper.Map <PenaltyDto, PenaltyModel>(dto);
await _unitOfWork.PenaltiesRepository.InsertAsync(model);
await _unitOfWork.SaveAsync();
return(dto);
}
public ActionResult Upload(PenaltyModel Model)
{
if (ModelState.IsValid)
{
foreach (PenaltyItem data in Model.Details)
{
try
{
var Exist = _penaltyBLL.GetPenalty().Where(x => (x.BodyType == null ? "" : x.BodyType.ToUpper()) == (data.BodyType == null ? "" : data.BodyType.ToUpper()) &&
(x.Manufacturer == null ? "" : x.Manufacturer.ToUpper()) == (data.Manufacturer == null ? "" : data.Manufacturer.ToUpper()) &&
(x.Model == null ? "" : x.Model.ToUpper()) == (data.Models == null ? "" : data.Models.ToUpper()) &&
(x.VehicleType == null ? "" : x.VehicleType.ToUpper()) == (data.VehicleType == null ? "" : data.VehicleType.ToUpper()) &&
(x.BodyType == null ? "" : x.BodyType.ToUpper()) == (data.BodyType == null ? "" : data.BodyType.ToUpper()) &&
(x.Series == null ? "" : x.Series.ToUpper()) == (data.Series == null ? "" : data.Series.ToUpper()) &&
x.Year == data.Year && x.Vendor == data.Vendor && x.Penalty == data.Penalty && x.MonthEnd == data.MonthEnd && x.MonthStart == data.MonthStart && x.IsActive).FirstOrDefault();
if (Exist != null)
{
Exist.IsActive = false;
Exist.ModifiedBy = "SYSTEM";
Exist.ModifiedDate = DateTime.Now;
_penaltyBLL.Save(Exist);
}
data.CreatedDate = DateTime.Now;
data.CreatedBy = CurrentUser.USER_ID;;
data.ModifiedDate = null;
data.IsActive = true;
var dto = Mapper.Map <PenaltyDto>(data);
_penaltyBLL.Save(dto);
}
catch (Exception exception)
{
Model.ErrorMessage = exception.Message;
Model.MainMenu = _mainMenu;
Model.CurrentLogin = CurrentUser;
return(View(Model));
}
}
try
{
_penaltyBLL.SaveChanges();
}
catch (Exception EXP)
{
Model.ErrorMessage = EXP.Message;
Model.MainMenu = _mainMenu;
Model.CurrentLogin = CurrentUser;
return(View(Model));
}
}
return(RedirectToAction("Index", "MstPenalty"));
}
public async Task <PenaltyDto> DeactivateAsync(int deactivatorId, int penaltyId)
{
PenaltyModel model = await _unitOfWork.PenaltiesRepository.JoinAndGetAsync(penaltyId);
_unitOfWork.PenaltiesRepository.BeginUpdate(model);
model.DeactivatorId = deactivatorId;
model.Deactivated = true;
model.DeactivationDate = DateTime.Now;
await _unitOfWork.SaveAsync();
return(_mapper.Map <PenaltyModel, PenaltyDto>(model));
}
public async Task <PenaltyDto> UpdateAsync(int id, PenaltyDto dto)
{
dto.Account = null;
dto.Character = null;
dto.Creator = null;
PenaltyModel model = await _unitOfWork.PenaltiesRepository.GetAsync(id);
_mapper.Map(dto, model);
await _unitOfWork.SaveAsync();
return(dto);
}
public void AddPenalty(PenaltyModel model)
{
decimal paymentFromUI = model.Payment;
model.Payment = _data.AmountOfPayment(model.UserId, model.BookId);
if (paymentFromUI != model.Payment)
{
// Error message about diffrence in calculation UI - API
// Get UserId
}
_data.AddPenalty(model);
}
public async Task <IActionResult> Penalty(PenaltyModel model)
{
if (_signInManager.Context.User.Identity.IsAuthenticated)
{
if (_signInManager.Context.User.IsInRole("DepartmentHead"))
{
await Initializer.InitialLayout("Department", ViewBag, _db, _signInManager, "Penalty");
PenaltyModel pm = new PenaltyModel
{
Employee = await _db.Employees
.Where(e => e.Id == model.EmployeeId)
.FirstOrDefaultAsync()
};
if (ModelState.IsValid)
{
if (pm.Employee.LastCalculate < model.GivenDate)
{
Fine fine = new Fine
{
GivenDate = model.GivenDate,
Price = model.Price,
EmployeeId = model.EmployeeId
};
await _db.Fines.AddAsync(fine);
await _db.SaveChangesAsync();
}
else
{
ModelState.AddModelError("", "You can't add penalty to this time");
}
}
else
{
pm.GivenDate = model.GivenDate;
pm.Price = model.Price;
}
pm.Fines = await _db.Fines
.Where(b => b.EmployeeId == model.EmployeeId)
.ToListAsync();
return(View(pm));
}
}
return(RedirectToAction("Forbidden", "Error"));
}
public IActionResult AddPenalty(PenaltyModel penaltyModel)
{
if (ModelState.IsValid)
{
Penalty penalty = new Penalty
{
Date = penaltyModel.Date,
EmployeeId = penaltyModel.EmployeeId,
Amount = penaltyModel.Amount,
Reason = penaltyModel.Reason
};
context.Penalties.AddAsync(penalty);
context.SaveChangesAsync();
return(RedirectToAction("List"));
}
return(View());
}
public async Task <IActionResult> Penalty(int id)
{
if (_signInManager.Context.User.Identity.IsAuthenticated)
{
if (_signInManager.Context.User.IsInRole("DepartmentHead"))
{
await Initializer.InitialLayout("Department", ViewBag, _db, _signInManager, "Penalty");
PenaltyModel pm = new PenaltyModel
{
Fines = await _db.Fines
.Where(b => b.EmployeeId == id)
.ToListAsync(),
Employee = await _db.Employees
.Where(e => e.Id == id)
.FirstOrDefaultAsync()
};
return(View(pm));
}
}
return(RedirectToAction("Forbidden", "Error"));
}
public void Kick(AccountEntity creator, string reason)
{
RoleplayContext ctx = Singletons.RoleplayContextFactory.Create();
using (PenaltiesRepository repository = new PenaltiesRepository(ctx))
{
PenaltyModel model = new PenaltyModel()
{
CreatorId = creator?.DbModel.Id,
Account = DbModel,
Date = DateTime.Now,
PenaltyType = PenaltyType.Kick,
Reason = reason
};
repository.Insert(model);
repository.Save();
}
NAPI.Player.KickPlayer(Client, reason);
Dispose();
}
public PenaltyViewModel(IDbService _rep, PenaltyModel _pen)
{
repository = _rep;
penRef = _pen;
sumOpl = penRef.Sumopl;
}
public void AddPenalty(PenaltyModel model)
{
_dataAccess.SaveData("spPenalty_AddPenalty", new { model.UserId, model.BookId, model.BookRentId, model.Payment }, "LibraryDatabase");
}
