public async Task <IActionResult> Resubmission([Bind("Id,ManuscriptId,AEId,DateOfSubmission,ResponsetoDecision,EICDecision,SubmissionStatus,DecisionDate,EicDecisionText,DecisionLetter,PlagiarismConfirmation,DuplicateSubmissionConfirmation,CoverLetter,AEDecision,AEDecisionDate,AEDecisionText")] Submission submission)
{
var AllPreviousSubmissions = _context.Submissions.Where(a => a.ManuscriptId == submission.ManuscriptId);
foreach (var item in AllPreviousSubmissions)
{
item.SubmissionStatus = SubmissionStatus.NeglectedSubmission;
_context.Update(item);
}
if (ModelState.IsValid)
{
submission.DateOfSubmission = DateTime.Now;
submission.SubmissionStatus = SubmissionStatus.NotSubmitted;
submission.CoverLetter = submission.CoverLetter.Replace("\n", "<br/>");
submission.SubmissionStatus = SubmissionStatus.Submitted;
_context.Add(submission);
await _context.SaveChangesAsync();
return(RedirectToAction("ResubmissionFiles", "SubmissionFiles", new { /* routeValues, for example: */ sid = submission.Id }));
}
ViewData["AEId"] = new SelectList(_context.AreaEditors, "Id", "Description", submission.AEId);
ViewData["ManuscriptId"] = new SelectList(_context.Manuscripts, "Id", "ArAbstract", submission.ManuscriptId);
return(View(submission));
}
public async Task <IActionResult> Create([Bind("Id,BadgeId,UserId,DateofRequest,DateofGrant,IsRejected,RejectCount,RejectReason,IsGranted")] UserBadge userBadge)
{
//if (ModelState.IsValid)
//{
var Badge = _context.Badges
.SingleOrDefault(m => m.Id == userBadge.BadgeId);
var UserDetails = _context.Users
.SingleOrDefault(m => m.Id == userBadge.UserId);
userBadge.DateofGrant = DateTime.Now;
userBadge.DateofGrant = DateTime.Now;
userBadge.DateofRequest = DateTime.Now;
userBadge.IsGranted = true;
userBadge.RejectCount = 0;
userBadge.IsRejected = false;
//userBadge.UserId = id;
_context.Add(userBadge);
EmailContent content = _context.EmailContents.Where(m => m.Id == Badge.EmailContentId).SingleOrDefault();
await _emailSender.SendEmailAsync(UserDetails.Email, content.ArSubject, content.ArContent);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
//ViewData["BadgeId"] = new SelectList(_context.Badges, "Id", "ArBadgeName", userBadge.BadgeId);
////ViewData["UserId"] = new SelectList(_context.Users, "Id", "ArName", userBadge.UserId);
//ViewData["UserId"] = new SelectList(_userManager.Users.Where(u => u.Id == userBadge.UserId), "Id", "ArName");
//return View(userBadge);
}
public async Task <IActionResult> Create([Bind("Id,Name,Description,IsActive,ApplicationUserId,CreationDate,EmailContentId,ExpiryDate,EmailContentReminderId,IsEntBadgeRequired,ReminderDays,IsPdfInvitation,InvitationHeader,InvitationFooter,InvitationContext,EventDate")] RegistrationForm registrationForm, IFormFile myfile, IFormFile myfile1)
{
if (ModelState.IsValid)
{
registrationForm.InvitationHeader = await UserFile.UploadeNewFileAsync(registrationForm.InvitationHeader,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
registrationForm.InvitationFooter = await UserFile.UploadeNewFileAsync(registrationForm.InvitationFooter,
myfile1, _environment.WebRootPath, Properties.Resources.Secured);
if (registrationForm.InvitationContext != null)
{
registrationForm.InvitationContext = (System.Text.RegularExpressions.Regex.Replace(registrationForm.InvitationContext, @"(?></?\w+)(?>(?:[^>'""]+|'[^']*'|""[^""]*"")*)>", String.Empty)).Replace("\n", "<br/>");
}
registrationForm.ApplicationUserId = _userManager.GetUserId(User);
registrationForm.CreationDate = DateTime.Now;
_context.Add(registrationForm);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", registrationForm.ApplicationUserId);
ViewData["EmailContentId"] = new SelectList(_context.EmailContents, "Id", "ArSubject", registrationForm.EmailContentId);
ViewData["EmailContentReminderId"] = new SelectList(_context.EmailContents, "Id", "ArSubject", registrationForm.EmailContentReminderId);
return(View(registrationForm));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,Name,ShortName,BgImage,Logo,Description,CreationDate,CommunityType,SpecialityId,SecurityLevel,IsCommentsAllowed,IsFeatured,IsApproved,IsSuspended,Tags")] Community community, IFormFile myfile, IFormFile myfile1)
{
if (ModelState.IsValid)
{
community.ApplicationUserId = _userManager.GetUserId(User);
community.BgImage = await UserFile.UploadeNewFileAsync(community.BgImage,
myfile, _environment.WebRootPath, Properties.Resources.Community);
community.Logo = await UserFile.UploadeNewImageAsync(community.Logo,
myfile1, _environment.WebRootPath, Properties.Resources.Community, 50, 50);
community.CreationDate = DateTime.Now;
community.IsFeatured = false;
community.IsSuspended = false;
community.IsApproved = false;
community.IsCommentsAllowed = true;
community.SecurityLevel = SecurityLevel.Open;
community.CommunityType = CommunityType.Community;
_context.Add(community);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", community.ApplicationUserId);
ViewData["SpecialityId"] = new SelectList(_context.Specialities, "Id", "Name", community.SpecialityId);
return(View(community));
}
public async Task <IActionResult> Create([Bind("Id,Title,MOOCProviderId,Description,SpecialityId,IsFree,IsReported,Language,Certificate,Duration,UniversityId,Link,YouTubeLink,Tags,Instructor,Image,StartDate,ApplicationUserId,DateOfRecord")] MOOCList mOOCList, IFormFile myfile)
{
if (ModelState.IsValid)
{
mOOCList.ApplicationUserId = _userManager.GetUserId(User);
mOOCList.DateOfRecord = DateTime.Now;
mOOCList.Image = await UserFile.UploadeNewImageAsync(mOOCList.Image,
myfile, _environment.WebRootPath, Properties.Resources.ScientificEvent, 500, 500);
mOOCList.Description = mOOCList.Description.Replace("\n", "<br/>");
mOOCList.Id = Guid.NewGuid();
_context.Add(mOOCList);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", mOOCList.ApplicationUserId);
ViewData["MOOCProviderId"] = new SelectList(_context.MOOCProviders, "Id", "Name", mOOCList.MOOCProviderId);
ViewData["SpecialityId"] = new SelectList(_context.Specialities, "Id", "Name", mOOCList.SpecialityId);
// ViewData["UniversityId"] = new SelectList(_context.Universities, "Id", "ArUniversityName", mOOCList.UniversityId);
return(View(mOOCList));
}
public async Task <IActionResult> Create(string uid, [Bind("RecordDate,Details,Amount,Destination,ApplicationUserId,BalanceType")] Statement statement)
{
if (ModelState.IsValid)
{
if (statement.Details != null)
{
statement.Details = statement.Details.Replace("\n", "<br/>");
}
_context.Add(statement);
var user = _context.ApplicationUsers.SingleOrDefault(a => a.Id == statement.ApplicationUserId);
if (statement.Destination == true)
{
user.Balance = user.Balance + statement.Amount;
_context.Update(user);
}
else
{
user.Balance = user.Balance - statement.Amount;
_context.Update(user);
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(UserStatements), new { id = uid }));
}
//ViewData["FromApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", statement.ApplicationUser);
return(View(statement));
}
public async Task <IActionResult> Create([Bind("Id,ArName,EnName,ArDescription,EnDescription,ShortName,Logo,PISSN,EISSN,Email,ActivationDate,CreatedByUserId,EiCId,JournalStatus,Visitors,ReviewerCertificateBackgroundFile,JournalHeader,AuthorCertificateBackgroundFile,PublisherId")] Journal journal, IFormFile myfile, IFormFile myfile1, IFormFile myfile2, IFormFile myfile3)
{
if (ModelState.IsValid)
{
journal.Logo = await UserFile.UploadeNewImageAsync(journal.Logo,
myfile, _environment.WebRootPath, Properties.Resources.Images, 500, 500);
journal.JournalHeader = await UserFile.UploadeNewImageAsync(journal.JournalHeader,
myfile1, _environment.WebRootPath, Properties.Resources.Images, 500, 500);
journal.ReviewerCertificateBackgroundFile = await UserFile.UploadeNewFileAsync(journal.ReviewerCertificateBackgroundFile,
myfile2, _environment.WebRootPath, Properties.Resources.Images);
journal.AuthorCertificateBackgroundFile = await UserFile.UploadeNewFileAsync(journal.AuthorCertificateBackgroundFile,
myfile3, _environment.WebRootPath, Properties.Resources.Images);
journal.CreatedByUserId = _userManager.GetUserId(User);
journal.ArDescription = journal.ArDescription.Replace("\n", "<br/>");
journal.EnDescription = journal.EnDescription.Replace("\n", "<br/>");
journal.ActivationDate = DateTime.Now;
journal.JournalStatus = JournalStatus.UnderReview;
_context.Add(journal);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicantUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", journal.CreatedByUserId);
ViewData["EditorinChiefId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", journal.EiCId);
ViewData["PublisherId"] = new SelectList(_context.Publishers, "Id", "ArName", journal.PublisherId);
return(View(journal));
}
public async Task <IActionResult> Create([Bind("Id,Title,Description,Indx,CourseChapterId,ContentType,FilePath,Duration,IsFree,IsDownloadable")] CourseChapterContent courseChapterContent, Guid cid, IFormFile myfile)
{
if (ModelState.IsValid)
{
courseChapterContent.FilePath = await UserFile.UploadeNewFileAsync(courseChapterContent.FilePath,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
if (courseChapterContent.ContentType == ContentType.youtube)
{
int position = courseChapterContent.FilePath.IndexOf("=");
courseChapterContent.FilePath = courseChapterContent.FilePath.Substring(position + 1);
}
courseChapterContent.Description = courseChapterContent.Description.Replace("\n", "<br/>");
courseChapterContent.Id = Guid.NewGuid();
_context.Add(courseChapterContent);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "CourseChapters", new { /* routeValues, for example: */ id = courseChapterContent.CourseChapterId }));
}
ViewData["CourseChapterId"] = new SelectList(_context.CourseChapters, "Id", "Name", courseChapterContent.CourseChapterId);
return(View(courseChapterContent));
}
public async Task <IActionResult> Create(
[Bind("Id,ArUniversityName,EnUniversityName,Website,StaffNo,StudentNo,LogoHD,LogoThumb,YearofEstablishment,Governmental,SemiPrivate,Private,CountryId,IsIndexed")] University university,
IFormFile myfile)
{
if (ModelState.IsValid)
{
university.LogoHD = await UserFile.UploadeNewImageAsync(university.LogoHD,
myfile, _environment.WebRootPath, Properties.Resources.UniversityLogoFolder, 400, 400);
_context.Add(university);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["CountryId"] = new SelectList(_context.Countries, "Id", "ArCountryName", university.CountryId);
return(View(university));
}
public async Task <IActionResult> CreateComment([Bind("Id,Comment,DateTime,IsHidden,IsFeatured,IsDeleted,PostId,ApplicationUserId")] PostComment postComment, Guid PostId)
{
if (ModelState.IsValid)
{
postComment.ApplicationUserId = _userManager.GetUserId(User);
postComment.DateTime = DateTime.Now;
postComment.IsDeleted = false;
postComment.IsFeatured = false;
postComment.IsHidden = false;
postComment.PostId = PostId;
postComment.Id = Guid.NewGuid();
_context.Add(postComment);
_context.ScoreLogs.Add(new ScoreLog
{
Id = Guid.NewGuid(),
ApplicationUserId = _userManager.GetUserId(User),
PostId = PostId,
Date = DateTime.Now,
ScoreValueId = 3
});
//addnotification{
var post = _context.Posts.Include(p => p.ApplicationUser).SingleOrDefault(p => p.Id == PostId);
var commenter = _context.Users.SingleOrDefault(u => u.Id == _userManager.GetUserId(User));
_context.Notifications.Add(new Notification
{
Id = Guid.NewGuid(),
ApplicationUserId = post.ApplicationUserId,
Content = "علق " + commenter.ArName + " على منشورك",
Url = "https://portal.arid.my/ar-LY/Posts/Details/" + PostId + "",
CreationDate = DateTime.Now,
SenderId = _userManager.GetUserId(User),
IsDeleted = false,
IsRead = false,
});
//}
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = PostId }));
}
return(RedirectToAction("Details", new { id = PostId }));
}
public async Task<IActionResult> Create([Bind("Id,Name,NotifyEmail,Status")] TicketCategory ticketCategory)
{
if (ModelState.IsValid)
{
_context.Add(ticketCategory);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
return View(ticketCategory);
}
public async Task <IActionResult> Create([Bind("Id,Email,ArDescription,EnDescription")] Sender sender)
{
if (ModelState.IsValid)
{
_context.Add(sender);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(sender));
}
public async Task <IActionResult> Create([Bind("Id,ArDegreeName,EnDegreeName,Indx")] AcademicDegree academicDegree)
{
if (ModelState.IsValid)
{
_context.Add(academicDegree);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(academicDegree));
}
public async Task <IActionResult> Create([Bind("Id,Name,Value")] ScoreValue scoreValue)
{
if (ModelState.IsValid)
{
_context.Add(scoreValue);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(scoreValue));
}
public async Task <IActionResult> Create([Bind("Id,ArPositionName,EnPositionName,IsApproved")] PositionType positionType)
{
if (ModelState.IsValid)
{
_context.Add(positionType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(positionType));
}
public async Task <IActionResult> Create([Bind("Id,Name,EnSpecialityName")] Speciality speciality)
{
if (ModelState.IsValid)
{
_context.Add(speciality);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(speciality));
}
public async Task <IActionResult> Create([Bind("Id,Type")] ArticleType articleType)
{
if (ModelState.IsValid)
{
_context.Add(articleType);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(articleType));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,AnswerDate,CourseChapterChoiceId")] CourseChapterExamLog courseChapterExamLog)
{
if (ModelState.IsValid)
{
_context.Add(courseChapterExamLog);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", courseChapterExamLog.ApplicationUserId);
return(View(courseChapterExamLog));
}
public async Task <IActionResult> Create([Bind("Id,CourseChapterContentId,ApplicationUserId,DateOfRecord,Status")] ChapterStudyStatus chapterStudyStatus)
{
if (ModelState.IsValid)
{
_context.Add(chapterStudyStatus);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", chapterStudyStatus.ApplicationUserId);
return(View(chapterStudyStatus));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,ArDescription,EnDescription,ArTitle,EnTitle,IsCurrent,FromYear,ToYear,Indx")] TeachingExperience teachingExperience)
{
if (ModelState.IsValid)
{
_context.Add(teachingExperience);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = _userManager.GetUserId(User);
return(View(teachingExperience));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,FreelancerProjectId,Isvisible,DateofRecord,Comment,Professionalism,Communication,Quality,Experience,Delivery,RehirePossibility")] FreelancerRating freelancerRating)
{
if (ModelState.IsValid)
{
_context.Add(freelancerRating);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", freelancerRating.ApplicationUserId);
return(View(freelancerRating));
}
public async Task <IActionResult> Create([Bind("Id,ArCityName,EnCityName,CountryId")] City city)
{
if (ModelState.IsValid)
{
_context.Add(city);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["CountryId"] = new SelectList(_context.Countries, "Id", "ArCountryName", city.CountryId);
return(View(city));
}
public async Task <IActionResult> Create([Bind("Id,ArContent,EnContent,ArSubject,EnSubject,SenderId,UniqueName")] EmailContent emailContent)
{
if (ModelState.IsValid)
{
_context.Add(emailContent);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["SenderId"] = new SelectList(_context.Senders, "Id", "Email", emailContent.SenderId);
return(View(emailContent));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,Description,OriginalImage,ThumbImage")] Gallary gallary)
{
if (ModelState.IsValid)
{
_context.Add(gallary);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", gallary.ApplicationUserId);
return(View(gallary));
}
public async Task <IActionResult> Create([Bind("Id,Name,SkillCategoryType,ApplicationUserId")] Skill skill)
{
if (ModelState.IsValid)
{
_context.Add(skill);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUsers, "Id", "Id", skill.ApplicationUserId);
return(View(skill));
}
public async Task <IActionResult> Create(int jid, [Bind("Year,Description,JournalId,IsPublished,Name")] Volume volume)
{
if (ModelState.IsValid)
{
_context.Add(volume);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { id = jid }));
}
ViewData["JournalId"] = new SelectList(_context.Journals, "Id", "ArName", volume.JournalId);
return(View(volume));
}
public async Task <IActionResult> Create([Bind("Id,SubmissionId,JournalFileTypeId,FileName,Description")] SubmissionFile submissionFile, IFormFile myfile)
{
if (ModelState.IsValid)
{
if (submissionFile.Description != null)
{
submissionFile.Description = submissionFile.Description.Replace("\n", "<br/>");
}
submissionFile.FileName = await UserFile.UploadeNewFileAsync(submissionFile.FileName,
myfile, _environment.WebRootPath, Properties.Resources.Secured);
_context.Add(submissionFile);
await _context.SaveChangesAsync();
return(RedirectToAction("Create", "SubmissionFiles", new { /* routeValues, for example: */ sid = submissionFile.SubmissionId }));
}
ViewData["JournalFileTypeId"] = new SelectList(_context.JournalFileTypes, "Id", "Id", submissionFile.JournalFileTypeId);
ViewData["SubmissionId"] = new SelectList(_context.Submissions, "Id", "CoverLetter", submissionFile.SubmissionId);
return(View(submissionFile));
}
public async Task <IActionResult> Create(int jid, [Bind("JournalId,SpecialityId")] JournalSpeciality journalSpeciality)
{
if (ModelState.IsValid)
{
_context.Add(journalSpeciality);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { id = jid }));
}
ViewData["JournalId"] = new SelectList(_context.Journals, "Id", "ArName", journalSpeciality.JournalId);
ViewData["SpecialityId"] = new SelectList(_context.Specialities.Where(a => a.Name != null && _context.JournalSpecialities.Where(j => j.Speciality.Name == a.Name).Count() == 0), "Id", "Name", journalSpeciality.SpecialityId);
return(View(journalSpeciality));
}
public async Task <IActionResult> Create([Bind("Id,ApplicationUserId,ArProjectName,EnProjectName,ArDescription,EnDescription,ArDetails,EnDetails,CountryId,ProjectState,FromYear,ToYear")] Project project)
{
if (ModelState.IsValid)
{
_context.Add(project);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ApplicationUserId"] = _userManager.GetUserId(User);
ViewData["CountryId"] = new SelectList(_context.Countries, "Id", "ArCountryName");
return(View(project));
}
public async Task <IActionResult> Create([Bind("Id,Name,SpecialityId,UserId")] Expertise expertise)
{
if (ModelState.IsValid)
{
_context.Add(expertise);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["SpecialityId"] = new SelectList(_context.Specialities, "Id", "Name", expertise.SpecialityId);
ViewData["UserId"] = _userManager.GetUserId(User);
return(View(expertise));
}
