public IActionResult Add(AddClassViewModel classModel)
{
ClassBusiness classModelBusiness = new ClassBusiness();
var result = classModelBusiness.AddClass(classModel);
return(Ok(result));
}
public ActionResult AddClass(AddClassViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
HttpCookie conString = Request.Cookies.Get("rwxgqlb");
Class c = null;
try
{
c = new Class(model.Name, model.RollNo, model.TeacherId, Cryptography.Decrypt(conString.Value));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View());
}
ViewClassDetailsViewModel vcdvm = new ViewClassDetailsViewModel();
if (c != null)
{
vcdvm = new ViewClassDetailsViewModel
{
Id = c.ClassId,
Incharge = c.Incharge.Name,
Name = c.Name,
RollNo = c.RollNoIndex,
Sections = new List <ClassSection>(),
Strength = c.Strength,
Subjects = new List <ClassSubject>()
};
foreach (var item in c.GetSections())
{
vcdvm.Sections.Add(new ClassSection
{
Id = item.SectionId,
Name = item.Name,
Strength = item.Strength
});
}
foreach (var item in c.GetSubjects())
{
vcdvm.Subjects.Add(new ClassSubject
{
Id = item.SubjectId,
Name = item.Name
});
}
}
ViewBag.Success = true;
return(View("ViewClassDetails", vcdvm));
}
catch (Exception ex)
{
return(Content(ex.Message));
}
}
public int AddClass(AddClassViewModel addClassModel)
{
//throw new NotImplementedException();
var classData = Mapper.Map <AddClassViewModel, AddClass>(addClassModel);
_AddClassRepository.Add(classData);
_unitOfWork.Commit();
return(1);
}
// GET: Classes
public ActionResult Add()
{
var model = new AddClassViewModel {
TeacherClass = new Data.Models.Class {
TeacherId = SessionItems.TeacherId.Value
}, FirstTime = !DataRepository.GetTeachersClasses(SessionItems.TeacherId.Value).Any()
};
ViewBag.Title = model.FirstTime ? "Let's Get Started... " : string.Empty + "Add New Class";
return(View(model));
}
public IHttpActionResult Post([FromBody] AddClassViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var a = _iClassprofileService.AddClass(model);
return(Ok(a));
}
public async Task <ActionResult> Add(AddClassViewModel model)
{
if (_userSessionHelper.GetUserSession().IsUserLoggedIn)
{
model.CreatedBy = _userSessionHelper.GetUserSession().UserName;
string apiUrl = _appUrlHelper.GetApiUrl(ApiUrlPath.CLASS_ADD);
var result = await HttpUtilities.PostAsyncApi <ReturnResult <Class> >(apiUrl, JsonConvert.SerializeObject(model));
return(Json(result));
}
else
{
return(RedirectToAction("Index", "Account"));
}
}
public ActionResult Add(AddClassViewModel model)
{
Debug.Assert(SessionItems.TeacherId != null, "SessionItems.TeacherId != null");
if (DataRepository.CheckIfClassAlreadyExists(SessionItems.TeacherId.Value, model.TeacherClass.ClassName))
{
ModelState.AddModelError("alreadyExists", $"{model.TeacherClass.ClassName} already exists");
}
if (!ModelState.IsValid)
{
return(View(model));
}
DataRepository.CreateClass(model.TeacherClass);
return(RedirectToAction("Index"));
}
public IActionResult AddClass(AddClassViewModel addClassViewModel)
{
int userId = Convert.ToInt32(HttpContext.Session.GetInt32("UserId"));
using (var unitOfWork = new UnitOfWork(new CuriousDriveContext()))
{
Class @class = new Class();
@class.ClassName = addClassViewModel.className;
@class.Description = addClassViewModel.description;
@class.CreatedBy = @class.ModifiedBy = userId;
unitOfWork.Classes.Add(@class);
unitOfWork.Complete();
}
return(RedirectToAction("AddClass", "Admin"));
}
public int AddClass(AddClassViewModel addClassModel)
{
//Use Mapper.Initialize when mapper problem occcured---
// Mapper.Initialize(cfg =>
// {
// cfg.CreateMap<AddClassViewModel, AddClass>();
// cfg.CreateMap<AddClass, AddClassViewModel>();
// });
//throw new NotImplementedException();
var classData = Mapper.Map <AddClassViewModel, AddClass>(addClassModel);
_AddClassRepository.Add(classData);
_unitOfWork.Commit();
return(1);
}
public void AddClass(bool navigateToClassAfterAdd = false, Action <DataLayer.DataItems.DataItemClass> onClassAddedAction = null)
{
if (Classes == null)
{
throw new InvalidOperationException("Classes list was null");
}
if (CurrentSemesterId == Guid.Empty)
{
throw new InvalidOperationException("CurrentSemesterId was empty");
}
ShowPopup(AddClassViewModel.CreateForAdd(this, new AddClassViewModel.AddParameter()
{
Classes = Classes.ToArray(),
SemesterIdentifier = CurrentSemesterId,
NavigateToClassAfterAdd = navigateToClassAfterAdd,
OnClassAddedAction = onClassAddedAction
}));
}
public async Task <IHttpActionResult> CreateClass([FromBody] AddClassViewModel info)
{
#region Parameter validation
if (info == null)
{
info = new AddClassViewModel();
Validate(info);
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
#endregion
var classes = UnitOfWork.RepositoryClass.Search();
classes =
classes.Where(x => x.Name.Equals(info.Name, StringComparison.InvariantCultureIgnoreCase));
// Class exists.
if (await classes.AnyAsync())
{
return(ResponseMessage(
Request.CreateErrorResponse(HttpStatusCode.Conflict, HttpMessages.CannotBeDuplicated)));
}
var objClass = new Database.Models.Entities.Class
{
SpecializedId = info.SpecializedId,
Name = info.Name,
Status = MasterItemStatus.Active
};
objClass = UnitOfWork.RepositoryClass.Insert(objClass);
//await UnitOfWork.CommitAsync();
return(Ok(objClass));
}
public ReturnResult <Class> Add(AddClassViewModel model)
{
DbProvider dbProvider = new DbProvider();
string outCode = String.Empty;
string outMessage = String.Empty;
StoredProcedureConfigs <Class> storedProcedureConfigs = new StoredProcedureConfigs <Class>();
dbProvider.SetQuery(storedProcedureConfigs._INSERT_SINGLE_STORED_PROCEDURE, CommandType.StoredProcedure)
.SetParameter("Name", SqlDbType.NVarChar, model.Name, ParameterDirection.Input)
.SetParameter("Status", SqlDbType.Int, model.Status, ParameterDirection.Input)
.SetParameter("CreatedBy", SqlDbType.NVarChar, model.CreatedBy, ParameterDirection.Input)
.SetParameter("ERROR_CODE", SqlDbType.NVarChar, DBNull.Value, 100, ParameterDirection.Output)
.SetParameter("ERROR_MESSAGE", SqlDbType.NVarChar, DBNull.Value, 400, ParameterDirection.Output)
.ExcuteNonQuery()
.Complete();
dbProvider.GetOutValue("ERROR_CODE", out outCode)
.GetOutValue("ERROR_MESSAGE", out outMessage);
return(new ReturnResult <Class>()
{
ErrorCode = outCode,
ErrorMessage = outMessage,
});
}
public IActionResult AddClass()
{
AddClassViewModel addClassViewModel = new AddClassViewModel();
addClassViewModel.classesViewModel = new List <ClassViewModel>();
using (var unitOfWork = new UnitOfWork(new CuriousDriveContext()))
{
List <Class> classes = unitOfWork.Classes.GetAll().ToList();
foreach (Class @class in classes)
{
ClassViewModel classViewModel = new ClassViewModel();
classViewModel.classId = @class.ClassId;
classViewModel.className = @class.ClassName;
classViewModel.description = @class.Description;
addClassViewModel.classesViewModel.Add(classViewModel);
}
}
return(View(addClassViewModel));
}
public void EditClass(ViewItemClass c)
{
ShowPopup(AddClassViewModel.CreateForEdit(this, c));
}
public Addeditclass(ClassStudent classstudent)
{
InitializeComponent();
BindingContext = new AddClassViewModel(Navigation, classstudent);
}
public ReturnResult <Class> AddClass(AddClassViewModel mouse)
{
return(ClassDAL.Add(mouse));
}
