public void RemoveItem(long idItem, dtoEditAssignment assignment, List <dtoEditAssignment> assignments)
{
if (!SessionTimeout())
{
liteRepositoryItem item = Service.ItemGet(idItem);
if (item != null)
{
long permissions = (long)((item.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
switch (assignment.Type)
{
case AssignmentType.community:
if (!assignments.Any(a => a.IdPerson == UserContext.CurrentUserID))
{
assignments.Add(new dtoEditAssignment()
{
Id = 0, IdPerson = UserContext.CurrentUserID, CreatedOn = DateTime.Now, Permissions = permissions, Type = AssignmentType.person
});
}
break;
case AssignmentType.person:
break;
case AssignmentType.role:
break;
}
View.HasPendingChanges = true;
}
assignments = assignments.Where(a => !a.Equals(assignment)).ToList();
InitializeSelectors(item.Repository, assignments.Where(a => !a.IsDeleted && a.IdRole > 0).Select(a => a.IdRole).ToList(), assignments.Where(a => !a.IsDeleted && a.IdPerson > 0).Select(a => a.IdPerson).ToList());
}
}
private List <dtoItemToDelete> GetCascadePhisicalDelete(long idFirstFather, liteRepositoryItem folder, IEnumerable <liteRepositoryItem> allItems, List <liteRepositoryItem> toDelete, Boolean cascade)
{
List <dtoItemToDelete> results = new List <dtoItemToDelete>();
List <liteRepositoryItem> children = allItems.Where(i => i.IdFolder == folder.Id && i.IsFile).ToList();
toDelete.AddRange(children);
results.AddRange(children.Select(c => new dtoItemToDelete(c)
{
IsAddedForCascade = true, IdCascadeFirstFather = (cascade) ? idFirstFather : folder.Id
}).ToList());
foreach (liteRepositoryItem child in allItems.Where(i => i.IdFolder == folder.Id && !i.IsFile))
{
results.AddRange(GetCascadePhisicalDelete(idFirstFather, child, allItems, toDelete, true));
}
Boolean hasCascadeItems = results.Any();
results.Add(new dtoItemToDelete(folder)
{
HasCascadeItems = hasCascadeItems, IsAddedForCascade = cascade, IdCascadeFirstFather = idFirstFather
});
toDelete.Add(folder);
return(results);
}
public void TryToSave(long idItem, List <dtoEditAssignment> assignments, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.detailsNoPermissionToSave);
oType = ModuleRepository.GetObjectType(rItem.Type);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else if (rItem.Type == ItemType.Folder)
{
View.AskUserForApply(rItem.DisplayName);
}
else
{
SaveAssignments(idItem, assignments, false, tTranslations, translations, pTranslations);
}
}
else
{
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
}
public ScormPackageWithVersionToEvaluate ScormAddPendingEvaluation(liteRepositoryItem item, liteRepositoryItemVersion version, Int32 idPerson, long idLink = 0)
{
ScormPackageWithVersionToEvaluate pItem = null;
try
{
pItem = (from ScormPackageWithVersionToEvaluate i in Manager.GetIQ <ScormPackageWithVersionToEvaluate>()
where i.IdPerson == idPerson && i.IdItem == item.Id && i.IdVersion == version.Id && i.IdLink == idLink
select i).Skip(0).Take(1).ToList().FirstOrDefault();
Manager.BeginTransaction();
if (pItem == null)
{
pItem = new ScormPackageWithVersionToEvaluate();
pItem.IdItem = item.Id;
pItem.IdLink = idLink;
pItem.IdPerson = idPerson;
pItem.IdVersion = version.Id;
pItem.UniqueIdItem = item.UniqueId;
pItem.UniqueIdVersion = version.UniqueIdVersion;
}
pItem.IsPlaying = true;
pItem.Deleted = BaseStatusDeleted.None;
pItem.ToUpdate = true;
pItem.ModifiedOn = DateTime.Now;
Manager.SaveOrUpdate(pItem);
Manager.Commit();
}
catch (Exception ex)
{
Manager.RollBack();
pItem = null;
}
return(pItem);
}
public void UpdateForUpload(long idItem, Boolean allowUpload, List <dtoEditAssignment> assignments, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
View.AllowUpload = allowUpload;
if (rItem != null)
{
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
idCommunity = rItem.Repository.IdCommunity;
long permissions = (long)((rItem.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
Boolean reloadItems = Service.AssignmentsAddToItem(idItem, assignments.Where(a => !a.IsDeleted).ToList(), false);
View.HasPendingChanges = !reloadItems;
uAction = (reloadItems ? ModuleRepository.ActionType.PermissionsSaved : ModuleRepository.ActionType.PermissionsNotSaved);
if (reloadItems)
{
LoadAssignments(true, idItem, tTranslations, translations, pTranslations);
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
else
{
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
}
public void AddUsers(Boolean editMode, long idItem, List <Int32> idUsers, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations, List <dtoEditAssignment> assignments)
{
if (!SessionTimeout())
{
liteRepositoryItem item = Service.ItemGet(idItem);
if (item != null)
{
DateTime date = DateTime.Now;
long permissions = (long)((item.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
idUsers = idUsers.Where(i => !assignments.Any(a => a.IdPerson == i)).ToList();
View.HasPendingChanges = idUsers.Any();
List <litePerson> persons = CurrentManager.GetLitePersons(idUsers);
assignments.AddRange(persons.Select(i => new dtoEditAssignment()
{
CreatedOn = date, IdCommunity = item.Repository.IdCommunity, IdPerson = i.Id, DisplayName = i.SurnameAndName, Denyed = false, Permissions = permissions, Type = AssignmentType.person
}));
LoadAssignments(editMode, idItem, tTranslations, translations, pTranslations, assignments.Where(a => !a.IsDeleted).ToList());
}
}
}
public List <dtoModuleUploadedItem> AddFiles(String istanceIdentifier, Int32 idUploaderUser, Boolean allowAnonymousUpload, Boolean alwaysLastVersion, RepositoryIdentifier identifier, long idFolder, List <dtoUploadedItem> files, Object obj, long idObject, Int32 idObjectType, String moduleCode, Int32 idModuleAjaxAction, Int32 idModuleAction = 0)
{
List <dtoModuleUploadedItem> items = new List <dtoModuleUploadedItem>();
if (!SessionTimeout() || allowAnonymousUpload && idUploaderUser > 0)
{
litePerson person = Service.GetValidPerson(idUploaderUser);
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(identifier);
ModuleRepository module = Service.GetPermissions(identifier, idUploaderUser);
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.UnableToAddFile;
liteRepositoryItem item = (idFolder > 0 ? Service.ItemGet(idFolder) : null);
if (person == null || (item == null && idFolder > 0))
{
View.DisplayError(ItemUploadError.UnableToAddFileToUnknownFolder);
uAction = ModuleRepository.ActionType.UnknownItemFound;
InitializeView(idFolder, identifier, module, settings, CurrentManager.GetLitePerson(idUploaderUser));
}
else
{
Boolean allowAdd = module.Administration || module.ManageItems || module.UploadFile;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idFolder, UserContext.CurrentUserID, identifier, View.GetUnknownUserName());
if (dItem != null)
{
oType = ModuleRepository.GetObjectType(dItem.Type);
allowAdd = allowAdd || dItem.Permissions.GetActions().Contains(ItemAction.upload);
}
else if (idFolder == 0)
{
oType = ModuleRepository.ObjectType.Folder;
}
String folderName = (idFolder == 0 ? View.GetRootFolderName() : dItem.Name);
if (!allowAdd)
{
View.DisplayError(ItemUploadError.MissingPermissionsToAddFile, folderName, "", ItemType.Folder);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else
{
Boolean executed = false;
items = Service.FileAddToRepository(settings, istanceIdentifier, identifier, person, alwaysLastVersion, module, View.GetRepositoryDiskPath(), idFolder, files, obj, idObject, idObjectType, moduleCode, idModuleAjaxAction, idModuleAction);
executed = (items != null && items.Any(a => a.IsAdded));
uAction = (executed ? (items.Any(a => !a.IsAdded) ? ModuleRepository.ActionType.UnableToAddSomeFile : ModuleRepository.ActionType.AddFile) : ModuleRepository.ActionType.UnableToAddFile);
if (executed)
{
View.NotifyAddedItems(Service.GetIdModule(), idFolder, folderName, RootObject.RepositoryItems(identifier.Type, identifier.IdCommunity, -1, (dItem == null ? 0 : dItem.Id)), items.Where(a => a.ItemAdded != null).Select(f => f.ItemAdded).ToList());
}
else
{
View.DisplayError(ItemUploadError.UnableToAddFile, folderName, (items == null) ? null : items.Where(a => !a.IsAdded).Select(a => a.UploadedFile).ToList());
}
}
}
View.SendUserAction(identifier.IdCommunity, Service.GetIdModule(), uAction, idFolder, oType);
}
return(items);
}
public Boolean SaveItem(long idItem, String description, String name, String url, DisplayMode?mode, Boolean isVisible, Boolean allowUpload, List <String> tags)
{
Boolean executed = false;
if (SessionTimeout())
{
View.DisplaySessionTimeout();
}
else
{
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.GenericError;
Int32 idCommunity = UserContext.CurrentCommunityID;
liteRepositoryItem item = Service.ItemGet(idItem);
if (item == null)
{
View.DisplayUnknownItem(ItemAction.edit);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else
{
idCommunity = item.Repository.IdCommunity;
Int32 idCurrentUser = UserContext.CurrentUserID;
oType = ModuleRepository.GetObjectType(item.Type);
ItemSaving saving = Service.ItemSetBaseSettings(idItem, description, name, url, mode, isVisible, allowUpload, tags);
if (saving == ItemSaving.None)
{
View.DisplayUnavailableItem(ItemAction.edit);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else
{
executed = (saving == ItemSaving.Saved);
View.DisplayUpdateMessage(saving);
switch (saving)
{
case ItemSaving.Saved:
uAction = ModuleRepository.ActionType.ItemSavedDetails;
View.UpdateDefaultTags(ServiceTags.GetAvailableTags(idCurrentUser, idCommunity, Service.GetIdModule(), ModuleRepository.UniqueCode));
break;
case ItemSaving.None:
uAction = ModuleRepository.ActionType.ItemTryToSaveDetails;
break;
default:
uAction = ModuleRepository.ActionType.ItemSavedSomeDetails;
break;
}
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
return(executed);
}
public void SaveAssignments(long idItem, List <dtoEditAssignment> assignments, Boolean applyToContent, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations)
{
if (!SessionTimeout())
{
liteRepositoryItem rItem = Service.ItemGet(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ObjectType oType = ModuleRepository.ObjectType.File;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.VersionUnableToAdd;
if (rItem != null)
{
oType = ModuleRepository.GetObjectType(rItem.Type);
ModuleRepository module = Service.GetPermissions(rItem.Repository, UserContext.CurrentUserID);
Boolean reloadItems = false;
idCommunity = rItem.Repository.IdCommunity;
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(idItem, UserContext.CurrentUserID, rItem.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.detailsNoPermissionToSave);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else
{
oType = ModuleRepository.GetObjectType(dItem.Type);
applyToContent = applyToContent && dItem.Type == ItemType.Folder;
if (!dItem.Permissions.EditPermission)
{
View.DisplayUserMessage(UserMessageType.permissionsNoPermissionToSave);
uAction = ModuleRepository.ActionType.UnavailableItem;
}
else if (!assignments.Any(a => !a.Denyed))
{
View.DisplayUserMessage(UserMessageType.permissionsNoItemToSave);
uAction = ModuleRepository.ActionType.PermissionsNothingToSave;
}
else
{
long permissions = (long)((rItem.AllowUpload) ? ModuleRepository.Base2Permission.DownloadOrPlay | ModuleRepository.Base2Permission.Upload : ModuleRepository.Base2Permission.DownloadOrPlay);
assignments.Where(a => !a.Denyed && a.Permissions == 0).ToList().ForEach(a => a.Permissions = permissions);
reloadItems = Service.AssignmentsAddToItem(idItem, assignments.Where(a => !a.IsDeleted).ToList(), applyToContent);
View.HasPendingChanges = !reloadItems;
uAction = (reloadItems ? ModuleRepository.ActionType.PermissionsSaved : ModuleRepository.ActionType.PermissionsNotSaved);
View.DisplayUserMessage((reloadItems? UserMessageType.permissionsSaved : UserMessageType.permissionsUnableToSave));
}
}
if (reloadItems)
{
InitializeSelectors(dItem);
LoadAssignments(true, dItem.Id, tTranslations, translations, pTranslations);
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idItem, oType);
}
}
public String GetItemThumbnailFullPath(String baseThumbnailPath, liteRepositoryItem item)
{
if (item.HasThumbnail)
{
return(System.IO.Path.Combine(GetItemDiskPath(baseThumbnailPath, item.Repository), item.Thumbnail));
}
else
{
return("");
}
}
public List <long> GetIdFathers(liteRepositoryItem item)
{
List <long> fathers = new List <long>();
if (item != null && item.IdFolder > 0)
{
fathers.Add(item.IdFolder);
fathers.AddRange(GetIdFathers(item.IdFolder));
}
return(fathers);
}
public List <liteRepositoryItem> GetLiteFathers(long idFather, IEnumerable <liteRepositoryItem> repositoryItems)
{
List <liteRepositoryItem> fathers = new List <liteRepositoryItem>();
liteRepositoryItem father = repositoryItems.Where(f => f.Id == idFather).FirstOrDefault();
if (father != null && idFather > 0)
{
fathers.Add(father);
fathers.AddRange(GetLiteFathers(father.IdFolder, repositoryItems));
}
return(fathers);
}
public void ExecuteAction(long idItem, long idVersion, ItemAction action, String unknownUser, String repositoryPath, String thumnailPath)
{
if (!SessionTimeout())
{
Boolean reloadItems = false;
Int32 idCommunity = UserContext.CurrentCommunityID;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.GenericError;
liteRepositoryItemVersion version = Service.VersionGet(idVersion);
if (version == null)
{
View.DisplayUserMessage(UserMessageType.versionItemNotFound);
uAction = ModuleRepository.ActionType.UnknownItemFound;
}
else
{
liteRepositoryItem item = Service.ItemGet(version.IdItem);
if (item != null)
{
String path = repositoryPath;
switch (item.Repository.Type)
{
case RepositoryType.Portal:
path += "\\0";
break;
case RepositoryType.Community:
path += "\\" + item.Repository.IdCommunity.ToString();
break;
}
Boolean executed = false;
switch (action)
{
case ItemAction.addVersion:
RepositoryItemVersion vr = Service.VersionSetActive(idVersion);
reloadItems = (vr != null && vr.IsActive);
if (reloadItems)
{
View.CurrentVersionUpdated();
}
View.DisplayUserMessage((reloadItems ? UserMessageType.versionPromoted : UserMessageType.versionNotPromoted));
uAction = (reloadItems) ? ModuleRepository.ActionType.VersionSetAsActive : ModuleRepository.ActionType.VersionUnableToSetAsActive;
break;
}
if (reloadItems)
{
LoadVersions(item, unknownUser, repositoryPath);
}
}
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction, idVersion, ModuleRepository.ObjectType.VersionItem);
}
}
public liteRepositoryItem FolderGetRepository(RepositoryType type, Int32 idCommunity)
{
liteRepositoryItem root = null;
try
{
root = GetQuery(type, idCommunity).Where(i => i.Type == ItemType.RootFolder).ToList().FirstOrDefault();
}
catch (Exception ex)
{
throw ex;
}
return(root);
}
public String GetItemDiskFullPath(String baseFilePath, liteRepositoryItem item)
{
switch (item.Type)
{
case ItemType.Link:
case ItemType.Folder:
case ItemType.None:
case ItemType.RootFolder:
return("");
default:
return(System.IO.Path.Combine(GetItemDiskPath(baseFilePath, item.Repository), item.UniqueId.ToString() + item.Extension));
}
}
private void LoadVersions(liteRepositoryItem item, String unknownUser, String repositoryPath)
{
dtoDisplayRepositoryItem dItem = Service.GetItemWithPermissions(item.Id, UserContext.CurrentUserID, item.Repository, View.GetUnknownUserName());
if (dItem == null)
{
View.DisplayUserMessage(UserMessageType.versionItemNoPermission);
View.SendUserAction(item.IdCommunity, Service.GetIdModule(), ModuleRepository.ActionType.NoPermission, item.Id, ModuleRepository.GetObjectType(item.Type));
}
else
{
LoadVersions(true, dItem, unknownUser, repositoryPath);
}
}
private dtoDisplayObjectRepositoryItem Create(liteModuleLink link, liteRepositoryItem item, liteRepositoryItemVersion version)
{
dtoDisplayObjectRepositoryItem dto = new dtoDisplayObjectRepositoryItem(link, item, version);
String description = View.ExtraInfoDescription;
if (View.DisplayExtraInfo && !String.IsNullOrWhiteSpace(description))
{
dto.SetDescription(description);
}
if (View.DisplayLinkedBy || View.DisplayUploader)
{
Service.UpdateUserInfo(link, dto, View.GetUnknownUserName());
}
return(dto);
}
public Boolean StatisticsAddDownload(Int32 idPerson, RepositoryIdentifier rIdentifier, long idItem, Guid uniqueIdItem, long idVersion, Guid uniqueIdVersion, ItemType type, Int32 idCommunity)
{
Boolean result = false;
try{
DownloadStatistics stat = new DownloadStatistics();
stat.CreatedIPaddress = UC.IpAddress;
stat.CreatedOn = DateTime.Now;
stat.CreatedProxyIPaddress = UC.ProxyIpAddress;
stat.IdCommunity = idCommunity;
stat.IdItem = idItem;
stat.IdPerson = idPerson;
stat.IdVersion = idVersion;
stat.ItemType = type;
stat.UniqueIdItem = uniqueIdItem;
stat.UniqueIdVersion = uniqueIdVersion;
stat.RepositoryIdCommunity = rIdentifier.IdCommunity;
stat.RepositoryIdPerson = rIdentifier.IdPerson;
stat.RepositoryType = rIdentifier.Type;
Manager.SaveOrUpdate(stat);
result = true;
Boolean isIntransaction = Manager.IsInTransaction();
if (!isIntransaction)
{
Manager.BeginTransaction();
}
liteRepositoryItem item = Manager.Get <liteRepositoryItem>(idItem);
if (item != null)
{
item.Downloaded++;
Manager.SaveOrUpdate(item);
liteRepositoryItemVersion version = Manager.Get <liteRepositoryItemVersion>(idVersion);
if (version != null)
{
version.Downloaded++;
Manager.SaveOrUpdate(version);
}
}
if (!isIntransaction)
{
Manager.Commit();
}
}
catch (Exception ex)
{
}
return(result);
}
private List <dtoModuleActionControl> AnalyzeActions(Boolean getOnlyActions, dtoObjectRenderInitializer dto, DisplayActionMode dAction, StandardActionType actionsToDisplay)
{
List <dtoModuleActionControl> actions = new List <dtoModuleActionControl>();
if (dto.Link == null || dto.Link.DestinationItem == null)
{
if (getOnlyActions)
{
return(new List <dtoModuleActionControl>());
}
else
{
View.DisplayEmptyAction();
}
}
else
{
if (!getOnlyActions)
{
View.IdRequiredAction = dto.Link.Action;
View.Display = dAction;
}
liteRepositoryItem item = (dto.Link.DestinationItem.ObjectLongID == 0 ? null : Service.ItemGet(dto.Link.DestinationItem.ObjectLongID));
View.ItemType = (item == null ? ItemType.File : item.Type);
liteRepositoryItemVersion version = null;
if (dto.Link.DestinationItem.ObjectIdVersion > 0)
{
version = Service.VersionGet(dto.Link.DestinationItem.ObjectIdVersion);
}
if (!getOnlyActions && item == null)
{
View.DisplayRemovedObject();
}
else if (item != null)
{
liteRepositorySettings settings = Service.SettingsGetByRepositoryIdentifier(item.Repository);
dtoDisplayObjectRepositoryItem obj = Create(dto.Link, item, version);
View.ItemType = obj.Type;
if (dto.PlaceHolders.Where(p => !String.IsNullOrEmpty(p.Text)).Any() && (ValidateActionMode(dAction, DisplayActionMode.defaultAction) || ValidateActionMode(dAction, DisplayActionMode.text)))
{
View.DisplayPlaceHolders(dto.PlaceHolders.Where(p => !String.IsNullOrEmpty(p.Text)).ToList());
}
actions = AnalyzeModuleLinkItem(settings, obj, getOnlyActions, dto, dAction, actionsToDisplay);
}
}
return(actions);
}
private void RecalculateFatherSize(Boolean add, liteRepositoryItem child, IEnumerable <liteRepositoryItem> allItems, Int32 idPerson, DateTime date)
{
liteRepositoryItem father = allItems.Where(i => i.Id == child.IdFolder && i.Deleted == BaseStatusDeleted.None).FirstOrDefault();
if (child != null && father != null)
{
father.Size = (add ? father.Size + child.Size :father.Size - child.Size);
father.VersionsSize = (add ? father.VersionsSize + child.VersionsSize : father.VersionsSize - child.VersionsSize);
father.DeletedSize = (add ? father.DeletedSize + child.DeletedSize : father.DeletedSize - child.DeletedSize);
father.UpdateMetaInfo(idPerson, UC.IpAddress, UC.ProxyIpAddress, date);
Manager.SaveOrUpdate(father);
if (father.IdFolder > 0)
{
RecalculateUpperSize(add, father, child.Size, child.VersionsSize, child.DeletedSize, allItems, idPerson, date);
}
}
}
public dtoDisplayRepositoryItem GetItemWithPermissions(long idItem, Int32 idCurrentPerson, RepositoryIdentifier identifier, String unknownUser, Boolean externalAllowManage = false, Boolean externalAllowView = false)
{
liteRepositoryItem rItem = ItemGet(idItem);
if (rItem == null)
{
return(null);
}
else if (rItem.IsInternal)
{
return(dtoDisplayRepositoryItem.CreateFromInternal(new dtoRepositoryItem(rItem, null, Manager.GetLitePerson(rItem.IdOwner), Manager.GetLitePerson(rItem.IdModifiedBy), unknownUser), UC.CurrentUserID, externalAllowManage, externalAllowView));
}
else
{
return(GetItemWithPermissions(idItem, idCurrentPerson, identifier.Type, identifier.IdCommunity, unknownUser));
}
}
public void InitViewForRedirect(long idItem, Guid uniqueId, long idVersion, Guid uniqueIdVersion, ItemType type, long idLink, String language, Boolean saveCompleteness, Boolean isOnModal, Boolean refreshContainer, Boolean saveStatistics)
{
liteRepositoryItem item = Service.ItemGet(idItem);
liteRepositoryItemVersion version = Service.ItemGetVersion(idItem, idVersion);
if (item == null)
{
View.DisplayUnknownItem();
}
else if (version == null)
{
View.DisplayPlayUnavailable(item.DisplayName, item.Extension, type, (idVersion > 0), ItemAvailability.notavailable, item.Status);
}
else
{
View.RedirectTo(RootObject.FullPlay(idItem, version.UniqueIdItem, version.Id, version.UniqueIdVersion, version.Type, idLink, language, !saveStatistics, refreshContainer, isOnModal, saveCompleteness, View.PreloadSetBackUrl, View.PreloadBackUrl));
}
}
private dtoFolderTreeItem CreateFolderTreeItem(liteRepositoryItem fItem, long idCurrentFolder, IEnumerable <liteRepositoryItem> items, dtoFolderTreeItem father, ModuleRepository permissions)
{
dtoFolderTreeItem folder = new dtoFolderTreeItem()
{
Id = fItem.Id, Name = fItem.Name, IsCurrent = (idCurrentFolder == fItem.Id), IsInCurrentPath = (father.IsCurrent || father.IsInCurrentPath || (idCurrentFolder == fItem.Id))
};
folder.Size = fItem.Size;
folder.VersionsSize = fItem.VersionsSize;
folder.DeletedSize = fItem.DeletedSize;
folder.Quota = dtoContainerQuota.Create(father.Quota, folder.FullSize);
folder.UploadAvailable = folder.MoveIntoAvailable && (permissions.Administration || permissions.ManageItems || permissions.UploadFile || permissions.EditOthersFiles || fItem.AllowUpload);
foreach (liteRepositoryItem child in items.Where(i => i.Deleted == BaseStatusDeleted.None && i.Type == ItemType.Folder && i.IdFolder == folder.Id).OrderBy(i => i.Name).ThenBy(i => i.Id))
{
folder.Children.Add(CreateFolderTreeItem(child, idCurrentFolder, items, folder, permissions));
}
return(folder);
}
public ModuleObject CreateModuleObject(Boolean alwaysLastVersion, liteRepositoryItem item, Int32 idModule)
{
ModuleObject obj = new ModuleObject();
obj.FQN = item.GetType().FullName;
obj.ObjectLongID = item.Id;
obj.ObjectOwner = item;
obj.ObjectTypeID = (Int32)item.Type;
if (!alwaysLastVersion)
{
obj.ObjectIdVersion = item.IdVersion;
}
else
{
obj.ObjectIdVersion = 0;
}
obj.ServiceCode = ModuleRepository.UniqueCode;
obj.ServiceID = idModule;
obj.CommunityID = item.IdCommunity;
return(obj);
}
public void InitView(Boolean isExternalPage, long idItem, long idVersion, Int32 idModule, long idLink, DownloadErrorType type)
{
liteRepositoryItem item = (idItem > 0) ? Service.ItemGet(idItem) : null;
Int32 idCommunity = (idLink > 0 ? Service.ModuleLinkGetIdSourceCommunity(idLink) : 0);
if (item != null)
{
RepositoryType repositoryType = (item.IdCommunity > 0 ? RepositoryType.Community : RepositoryType.Portal);
switch (repositoryType)
{
case RepositoryType.Community:
if (idCommunity == 0)
{
idCommunity = item.IdCommunity;
}
View.InitializeCommunityView(item.DisplayName, item.Extension, type, item.IdCommunity, ((idCommunity > 0) ? CurrentManager.GetCommunityName(idCommunity) : ""));
break;
case RepositoryType.Portal:
View.InitializePortalView(item.DisplayName, item.Extension, type);
break;
break;
}
}
else
{
View.InitializeView(type);
}
if (isExternalPage)
{
View.InitializeContext(GetContext(idCommunity, idItem, idVersion, idModule, item));
}
else
{
View.InitializeContext();
}
}
private void DeleteItems(IEnumerable <dtoItemToDelete> items, List <liteRepositoryItem> rItems, Dictionary <long, List <String> > fileNames, List <liteFileTransfer> transfers)
{
foreach (dtoItemToDelete item in items)
{
try
{
liteRepositoryItem itemToDelete = Manager.Get <liteRepositoryItem>(item.Id);
if (itemToDelete != null)
{
Manager.BeginTransaction();
if (item.IsFile)
{
foreach (liteFileTransfer transfer in transfers.Where(t => t.IdItem == item.Id))
{
transfer.Status = TransferStatus.Deleting;
transfer.ModifiedOn = DateTime.Now;
}
}
Manager.DeletePhysical(itemToDelete);
rItems = rItems.Where(i => i.Id != item.Id).ToList();
RecalculateDeletedSize(rItems.Where(i => i.Id == item.IdFolder).FirstOrDefault(), rItems, true);
Manager.Commit();
item.IsDeleted = true;
if (fileNames.ContainsKey(item.Id))
{
lm.Comol.Core.File.Delete.Files(fileNames[item.Id]);
}
}
}
catch (Exception ex)
{
Manager.RollBack();
item.IsDeleted = false;
}
}
}
public void InitView(long idLink, long idItem, long idVersion, long idFolder, String path, Boolean setBackUrl, String backUrl)
{
RepositoryIdentifier rIdentifier = Service.ItemGetRepositoryIdentifier(idItem);
Int32 idCommunity = UserContext.CurrentCommunityID;
View.IdItem = idItem;
View.IdVersion = idVersion;
View.IdLink = idLink;
View.IdCurrentFolder = idFolder;
View.CurrentFolderIdentifierPath = path;
if (setBackUrl && String.IsNullOrEmpty(backUrl))
{
backUrl = View.GetPreviousRelativeUrl();
if (!IsValidPreviousUrl(backUrl))
{
backUrl = "";
setBackUrl = false;
}
if (backUrl.StartsWith(RootObject.BaseRepositoryUrl(), StringComparison.InvariantCultureIgnoreCase) && rIdentifier != null)
{
cookieRepository cookie = View.GetRepositoryCookie(rIdentifier);
if (cookie != null)
{
backUrl = RootObject.RepositoryItems(rIdentifier.Type, rIdentifier.IdCommunity, 0, cookie.IdFolder, cookie.Type, cookie.ItemsOrderBy, cookie.Ascending, cookie.IdentifierPath);
}
}
SetLogoutUrl(View.GetCurrentUrl(), setBackUrl, backUrl);
}
else
{
View.DefaultLogoutUrl = View.GetCurrentUrl();
}
View.BackUrl = (setBackUrl ? backUrl : "");
View.SetPageBackUrl(backUrl);
View.PageIdentifier = Guid.NewGuid();
if (SessionTimeout())
{
return;
}
View.IsInitialized = true;
ModuleRepository.ActionType uAction = ModuleRepository.ActionType.None;
if (rIdentifier == null)
{
uAction = ModuleRepository.ActionType.MultimedaSettingsTryToLoad;
View.DisplayUnknownItem();
}
else
{
Int32 idCurrentUser = UserContext.CurrentUserID;
liteRepositoryItem item = Service.ItemGet(idItem);
liteRepositoryItemVersion version = Service.ItemGetVersion(idItem, idVersion);
if (version == null)
{
uAction = ModuleRepository.ActionType.MultimedaSettingsTryToLoad;
View.DisplayUnknownItem();
}
else if (version.Type != ItemType.Multimedia)
{
idCommunity = version.IdCommunity;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidType);
uAction = ModuleRepository.ActionType.MultimedaSettingsInvalidType;
}
else
{
idVersion = version.Id;
View.IdVersion = idVersion;
idCommunity = version.IdCommunity;
if (version.Availability == ItemAvailability.available || version.Availability == ItemAvailability.waitingsettings)
{
ItemPermission permissions = null;
if (idLink == 0)
{
dtoDisplayRepositoryItem dto = Service.GetItemWithPermissions(idItem, idCurrentUser, item.Repository, View.GetUnknownUserName());
if (dto != null)
{
permissions = dto.Permissions;
}
}
else
{
liteModuleLink link = CurrentManager.Get <liteModuleLink>(idLink);
if (link == null)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoPermission);
}
else
{
permissions = View.GetLinkPermissions(link, idCurrentUser);
idCommunity = link.SourceItem.CommunityID;
}
}
if (permissions != null)
{
if (permissions.EditSettings)
{
if (version.Availability == ItemAvailability.waitingsettings)
{
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoDefaultDocument);
}
List <dtoMultimediaFileObject> items = Service.MultimediaGetItems(idItem, idVersion);
View.AllowSave = (items != null && items.Any());
View.LoadItems(item.UniqueIdVersion.ToString(), item.DisplayName, items, (items == null ? null : items.Where(i => i.IsDefaultDocument).FirstOrDefault()));
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsNoPermissions;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsNoPermission);
}
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsStatusError;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidStatus, version.Availability);
}
}
else
{
uAction = ModuleRepository.ActionType.MultimedaSettingsStatusError;
View.DisplayMessage(version.DisplayName, version.Extension, version.Type, Domain.UserMessageType.multimediaSettingsInvalidStatus, version.Availability);
}
}
View.RepositoryIdentifier = CacheKeys.RepositoryIdentifierKey(rIdentifier.Type, rIdentifier.IdCommunity);
View.RepositoryIdCommunity = rIdentifier.IdCommunity;
View.RepositoryType = rIdentifier.Type;
View.IsInitialized = true;
}
View.SendUserAction(idCommunity, Service.GetIdModule(), uAction);
}
public lm.Comol.Core.DomainModel.Helpers.ExternalPageContext GetContext(Int32 idCommunity, long idItem, long idVersion, Int32 idModule, liteRepositoryItem item)
{
lm.Comol.Core.DomainModel.Helpers.ExternalPageContext context = new lm.Comol.Core.DomainModel.Helpers.ExternalPageContext();
context.Skin = new DomainModel.Helpers.dtoItemSkin();
context.Skin.IdCommunity = idCommunity;
if (idCommunity > 0)
{
context.Skin.IdOrganization = CurrentManager.GetIdOrganizationFromCommunity(idCommunity);
}
else
{
context.Skin.IsForPortal = true;
}
context.Source = new ModuleObject()
{
CommunityID = idCommunity, ObjectLongID = idItem, ObjectIdVersion = idVersion, ServiceID = idModule, FQN = typeof(liteRepositoryItem).FullName
};
if (item == null)
{
context.Source.ObjectTypeID = (int)ModuleRepository.ObjectType.File;
}
else
{
switch (item.Type)
{
case ItemType.File:
context.Source.ObjectTypeID = (int)ModuleRepository.ObjectType.File;
break;
case ItemType.Multimedia:
context.Source.ObjectTypeID = (int)ModuleRepository.ObjectType.File;
break;
case ItemType.ScormPackage:
context.Source.ObjectTypeID = (int)ModuleRepository.ObjectType.ScormPackage;
break;
}
}
return(context);
}
public ModuleActionLink CreateModuleAction(Int32 permission, Boolean alwaysLastVersion, liteRepositoryItem item, Int32 idModule)
{
return(new ModuleActionLink(permission, (Int32)ItemGetDefaultAction(item.Type))
{
ModuleObject = CreateModuleObject(alwaysLastVersion, item, idModule), EditEnabled = false
});
}
public liteRepositoryItem ItemMoveTo(long idItem, long idSource, long idDestination, RepositoryType type, Int32 idCommunity)
{
liteRepositoryItem item = null;
try
{
List <liteRepositoryItem> items = GetQuery(type, idCommunity).ToList();
item = items.Where(i => i.Id == idItem).FirstOrDefault();
litePerson person = GetValidPerson(UC.CurrentUserID);
if (person != null && item != null && item.Deleted == BaseStatusDeleted.None && item.IdFolder == idSource)
{
DateTime modifiedOn = DateTime.Now;
liteRepositoryItem sFolder = items.Where(i => i.Id == item.IdFolder && i.Deleted == BaseStatusDeleted.None).FirstOrDefault();
Manager.BeginTransaction();
if (idDestination == 0 && sFolder != null)
{
RecalculateFatherSize(false, item, items, person.Id, modifiedOn);
item.IdFolder = 0;
if (ItemHasDuplicate(item, 0, items))
{
item.Name = ItemGetSuggestedName(item, items);
}
item.DisplayOrder = long.MaxValue - 1;
RecalculateDisplayOrderForFolder(idDestination, items, person.Id, modifiedOn);
item.UpdateMetaInfo(person.Id, UC.IpAddress, UC.ProxyIpAddress, modifiedOn);
Manager.SaveOrUpdate(item);
}
else if (idDestination > 0)
{
liteRepositoryItem dFolder = items.Where(i => i.Id == idDestination && i.Deleted == BaseStatusDeleted.None).FirstOrDefault();
if (dFolder != null)
{
if (sFolder != null)
{
RecalculateFatherSize(false, item, items, person.Id, modifiedOn);
}
item.IdFolder = idDestination;
if (ItemHasDuplicate(item, idDestination, items))
{
item.Name = ItemGetSuggestedName(item, items);
}
RecalculateFatherSize(true, item, items, person.Id, modifiedOn);
item.DisplayOrder = long.MaxValue - 1;
RecalculateDisplayOrderForFolder(idDestination, items, person.Id, modifiedOn);
item.UpdateMetaInfo(person.Id, UC.IpAddress, UC.ProxyIpAddress, modifiedOn);
Manager.SaveOrUpdate(item);
}
}
Manager.Commit();
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.Repository(type, idCommunity));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersViewOfRepository(type, idCommunity));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersSizeViewOfRepository(type, idCommunity));
}
}
catch (Exception ex)
{
Manager.RollBack();
}
return(item);
}
