public static ManualCreate GetViewModel(BaseController baseController)
{
var manualCreate = new ManualCreate();
manualCreate.Ensure(baseController);
return manualCreate;
}
public static TaskIndex GetViewModel(BaseController baseController)
{
PeopleContactTask[] peopleContactTasks = PeopleContactCache.GetPeopleContactTasks(baseController.Db, baseController.UserId);
var taskIndex = new TaskIndex
{
ActualTasks = peopleContactTasks.Where(pct => pct.PeopleContactTaskType == PeopleContactTaskType.Actual).ToArray(),
DelayedTasks = peopleContactTasks.Where(pct => pct.PeopleContactTaskType == PeopleContactTaskType.Delayed).ToArray()
};
return taskIndex;
}
private void ValidateConfirms(BaseController baseController)
{
if (!ConfirmTermsAndConditions)
{
baseController.ModelState.AddModelError(BaseCache.ConfirmTermsAndConditionsField, ValidationResource.PeopleContact_NotConfirmedTermsAndConditions_ErrorMessage);
}
if (!ConfirmPersonalData)
{
baseController.ModelState.AddModelError(BaseCache.ConfirmPersonalDataField, ValidationResource.PeopleContact_NotConfirmedPersonalData_ErrorMessage);
}
}
public static ManualCreate GetViewModel(BaseController baseController, ManualCreate manualCreate)
{
manualCreate.Ensure(baseController);
manualCreate.Validate(baseController);
if (!baseController.ModelState.IsValid)
return manualCreate;
Manual manual = manualCreate.GetModel();
ManualCache.Insert(baseController.Db, manual);
return manualCreate;
}
public void Validate(BaseController baseController)
{
ValidateEmailBodies(baseController);
CalculateFolderRemainMB(baseController.Server, FileStore.Videos);
ValidateFile(baseController, File, FileStore.Videos, Properties.Settings.Default.MaxVideoUploadSizeMB, allowedExtensions: AllowedExtensions);
}
public static UserProfilePromote GetViewModel(BaseController baseController, int id, string returnUrl)
{
var allowedReturnUrl = new[] { "Index", "IndexTree" };
if (baseController == null || id == 0 || !allowedReturnUrl.Contains(returnUrl))
return null;
var userProfilePromote = new UserProfilePromote(baseController, id, returnUrl);
userProfilePromote.Validate();
userProfilePromote.Process();
return userProfilePromote;
}
private ManualsByTypeIndex(BaseController baseController, ManualType manualType, int pageNumber, int pageSize)
{
Title = String.Format("{0} - {1}", ViewResource.ManualsByType_Index_Title_Text, manualType.Title);
Manuals = manualType.Manuals.OrderBy(m => m.Order).Select(m => new ManualDashboard.Manual(baseController, m)).ToPagedList(pageNumber, pageSize);
}
public static ManualPlayer GetViewModel(BaseController baseController, int id)
{
Manual manual = ManualCache.GetDetail(baseController.Db, id);
if (manual == null)
return null;
var manualPlayer = new ManualPlayer(baseController, manual);
return manualPlayer;
}
private ManualPlayer(BaseController baseController, Manual manual)
{
_isValid = true;
_baseController = baseController;
_manual = manual;
_contentType = HttpResponseBaseService.ContentType.Txt;
if (baseController == null || manual == null || (!manual.IsAccessForAuthGuest && baseController.IsAuthenticatedGuest))
{
_isValid = false;
return;
}
Title = manual.Title;
PlayerDataUrl = baseController.Url.Action("PlayerData", "Manual", new { id = manual.ManualId });
ProcessFindFilePath();
CheckPlayer();
}
public static ManualDelete GetViewModel(BaseController baseController, int id)
{
Manual manual = ManualCache.GetDetail(baseController.Db, id);
if (manual == null)
return null;
var manualDelete = new ManualDelete(manual);
return manualDelete;
}
public Manual(BaseController baseController, Models.Manual manual)
{
string token = Cryptography.Encrypt(manual.ManualId.ToString(CultureInfo.InvariantCulture));
bool canRead = !baseController.IsAuthenticatedGuest || baseController.IsAuthenticatedGuest && manual.IsAccessForAuthGuest;
bool canDownload = canRead && manual.IsDownloadable;
Title = manual.Title;
Token = token;
CanRead = canRead;
CanDownload = canDownload;
}
public static ManualDashboard GetViewModel(BaseController baseController)
{
Models.ManualType[] manualTypes = ManualTypeCache.GetIndex(baseController.Db);
if (manualTypes == null)
return null;
var manualDashboard = new ManualDashboard(baseController, manualTypes);
return manualDashboard;
}
public ManualDashboard(BaseController baseController, IEnumerable<Models.ManualType> manualTypes)
{
_baseController = baseController;
Models.ManualType[] orderedManualTypes = manualTypes.OrderBy(mt => mt.Order).ToArray();
ManualTypeItems = orderedManualTypes.Select(GetManualTypeItem).ToArray();
ManualTypes = orderedManualTypes.Select(GetManualType).ToArray();
}
protected void ValidateManualType(BaseController baseController)
{
if (ManualTypeId == 0)
{
baseController.ModelState.AddModelError(BaseCache.ManualTypeIdField, String.Format(ValidationResource.Global_Required_ErrorMessage, FieldResource.ManualType_Title_Name));
}
}
protected void Ensure(BaseController baseController)
{
CalculateFolderRemainMB(baseController.Server, FileStore.Manuals);
PopulateManualTypeId(baseController.ViewBag, baseController.Db, ManualTypeId == 0 ? null : (object)ManualTypeId);
}
private void ValidateManualFile(BaseController baseController)
{
if (File == null)
return;
var dbManual = ManualCache.GetDetail(baseController.Db, ManualId);
if (dbManual == null)
throw new Exception("Cannot validate ManualEdit due to empty ManualId.");
RelativeFilePath = dbManual.RelativeFilePath;
string previousFileName = Path.GetFileName(RelativeFilePath);
ValidateFile(baseController, File, FileStore.Manuals, Properties.Settings.Default.MaxManualUploadSizeMB, previousFileName, AllowedExtensions);
}
public static IPagedList<ManualIndex> GetViewModel(BaseController baseController, int? page, int pageSize)
{
int pageNumber;
ProcessPaging(page, out pageNumber);
PopulatePageSize(baseController.ViewBag, pageSize);
ManualIndex[] manuals = ManualCache.GetIndex(baseController.Db).Select(m => new ManualIndex(m)).ToArray();
IPagedList<ManualIndex> viewModel = manuals.ToPagedList(pageNumber, pageSize);
return viewModel;
}
public static ManualDelete GetViewModel(BaseController baseController, int id, out DeleteResult deleteResult)
{
deleteResult = DeleteResult.Ok;
Manual manual = ManualCache.GetDetail(baseController.Db, id);
if (manual == null)
return null;
var manualDelete = new ManualDelete(manual);
manualDelete.Process(baseController);
if (baseController.ModelState.IsValid)
{
deleteResult = ManualCache.Delete(baseController.Db, manual);
switch (deleteResult)
{
case DeleteResult.Ok:
case DeleteResult.AuthorizationFailed:
return manualDelete;
case DeleteResult.DbFailed:
baseController.ModelState.AddModelError(BaseCache.TitleField, ValidationResource.Global_DeleteRecord_ErrorMessage);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return manualDelete;
}
private void Validate(BaseController baseController)
{
ValidateManualType(baseController);
ValidateFile(baseController, File, FileStore.Manuals, Properties.Settings.Default.MaxManualUploadSizeMB, allowedExtensions: AllowedExtensions);
}
private void Process(BaseController baseController)
{
ProcessManualFile(baseController);
}
public static ManualPlayer GetViewModel(BaseController baseController, string token)
{
string decryptedToken = Cryptography.Decrypt(token);
if (String.IsNullOrEmpty(decryptedToken))
return null;
int id;
if (!Int32.TryParse(decryptedToken, out id))
return null;
var manualPlayer = GetViewModel(baseController, id);
return manualPlayer;
}
private ManualDetail(BaseController baseController, Manual manual)
{
ManualId = manual.ManualId;
Title = manual.Title;
ManualTypeTitle = manual.ManualType.Title;
Order = manual.Order;
Url = baseController.Url.Action("Player", "Manual", new { id = manual.ManualId });
IsDownloadable = manual.IsDownloadable;
IsAccessForAuthGuest = manual.IsAccessForAuthGuest;
}
public static ManualsByTypeIndex GetViewModel(BaseController baseController, int id, int? page, int pageSize)
{
int pageNumber;
ProcessPaging(page, out pageNumber);
PopulatePageSize(baseController.ViewBag, pageSize);
ManualType manualType = ManualTypeCache.GetDetail(baseController.Db, id);
if (manualType == null)
return null;
var viewModel = new ManualsByTypeIndex(baseController, manualType, pageNumber, pageSize);
return viewModel;
}
public static ManualEdit GetViewModel(BaseController baseController, int id)
{
Manual manual = ManualCache.GetDetail(baseController.Db, id);
if (manual == null)
return null;
var manualEdit = new ManualEdit(manual);
manualEdit.Ensure(baseController);
return manualEdit;
}
public void Validate(BaseController baseController)
{
ValidateFile(baseController, File, FileStore.None, 4);
ValidateConfirms(baseController);
}
public static ManualEdit GetViewModel(BaseController baseController, ManualEdit manualEdit)
{
manualEdit.Ensure(baseController);
manualEdit.Validate(baseController);
if (!baseController.ModelState.IsValid)
return manualEdit;
Manual manual = manualEdit.GetModel();
bool success = ManualCache.Update(baseController.Db, manual);
return success ? manualEdit : null;
}
private UserProfilePromote(BaseController baseController, int id, string returnUrl)
{
BaseController = baseController;
_userId = id;
ReturnUrl = returnUrl;
}
private void Validate(BaseController baseController)
{
ValidateManualType(baseController);
ValidateManualFile(baseController);
}
protected void ValidateFile(BaseController baseController, HttpPostedFileBase file, FileStore fileStore, int maxContentLengthMB, string previousFileName = null, string[] allowedExtensions = null)
{
if (!baseController.ModelState.IsValid)
return;
if (file == null)
{
baseController.ModelState.AddModelError(BaseCache.FileField, String.Format(ValidationResource.Global_Required_ErrorMessage, FieldResource.Global_ImportFile_Name));
return;
}
string fixedFileName = Path.GetFileName(file.FileName) ?? "___error.nfo";
if (allowedExtensions != null && allowedExtensions.Length > 0)
{
string fileExtension = Path.GetExtension(fixedFileName);
if (allowedExtensions.All(ae => !ae.Equals(fileExtension, StringComparison.InvariantCultureIgnoreCase)))
{
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_IncorrectFileFormat_ErrorMessage);
return;
}
}
if (fixedFileName.Length > 100)
{
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_BadFileName_ErrorMessage);
return;
}
if (file.ContentLength == 0)
{
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_FileIsEmpty_ErrorMessage);
return;
}
if (file.ContentLength > 1024 * 1024 * (long)maxContentLengthMB)
{
baseController.ModelState.AddModelError(BaseCache.FileField, String.Format(ValidationResource.Global_FileIsTooLarge_ErrorMessage, maxContentLengthMB));
return;
}
if (fileStore == FileStore.None)
return;
if (file.ContentLength > FolderRemainMB * (long)1048576)
{
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_StoreIsFull_ErrorMessage);
return;
}
string absoluteFolderPath;
string relativeFolderPath;
int folderQuota;
GetFolderPath(baseController.Server, fileStore, out absoluteFolderPath, out relativeFolderPath, out folderQuota);
string absolutePreviousFilePath = String.IsNullOrEmpty(previousFileName) ? null : Path.Combine(absoluteFolderPath, previousFileName);
string absoluteFilePath = Path.Combine(absoluteFolderPath, fixedFileName);
if (File.Exists(absoluteFilePath) && !absoluteFilePath.Equals(absolutePreviousFilePath, StringComparison.InvariantCultureIgnoreCase))
{
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_FileExists_ErrorMessage);
return;
}
if (!String.IsNullOrEmpty(absolutePreviousFilePath) && File.Exists(absolutePreviousFilePath))
{
File.Delete(absolutePreviousFilePath);
}
try
{
file.SaveAs(absoluteFilePath);
RelativeFilePath = Path.Combine(relativeFolderPath, fixedFileName);
var converter = new Converter(baseController.Server);
VideoFile videoFile = converter.GetVideoInfo(absoluteFilePath);
VideoDuration = Convert.ToInt32(videoFile.Duration.TotalSeconds);
}
catch (Exception e)
{
try
{
if (File.Exists(absoluteFilePath))
{
File.Delete(absoluteFilePath);
}
}
catch (Exception ex)
{
Logger.SetLog(ex);
}
Logger.SetLog(e);
baseController.ModelState.AddModelError(BaseCache.FileField, ValidationResource.Global_FileCannotBeSaved_ErrorMessage);
}
}
public void ValidateVideoFile(BaseController baseController)
{
if (File == null)
return;
var dbVideo = VideoCache.GetDetail(baseController.Db, VideoId);
if (dbVideo == null)
throw new Exception("Cannot validate VideoEdit due to empty VideoId.");
RelativeFilePath = dbVideo.RelativeFilePath;
CalculateFolderRemainMB(baseController.Server, FileStore.Videos);
string previousFileName = Path.GetFileName(RelativeFilePath);
ValidateFile(baseController, File, FileStore.Videos, Properties.Settings.Default.MaxVideoUploadSizeMB, previousFileName, AllowedExtensions);
}
