protected BaseIssuesViewModel()
{
Issues = IssuesCollection.CreateDerivedCollection(x => x);
var gotoIssueCommand = ReactiveCommand.Create();
gotoIssueCommand.OfType <IssueModel>().Subscribe(x =>
{
var isPullRequest = x.PullRequest != null && !(string.IsNullOrEmpty(x.PullRequest.HtmlUrl));
var s1 = x.Url.Substring(x.Url.IndexOf("/repos/", StringComparison.Ordinal) + 7);
var repoId = new RepositoryIdentifier(s1.Substring(0, s1.IndexOf("/issues", StringComparison.Ordinal)));
if (isPullRequest)
{
var vm = CreateViewModel <PullRequestViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
vm.PullRequestId = x.Number;
ShowViewModel(vm);
}
else
{
var vm = CreateViewModel <IssueViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
vm.IssueId = x.Number;
ShowViewModel(vm);
}
});
GoToIssueCommand = gotoIssueCommand;
}
public static cookieRepository CreateFromString(RepositoryIdentifier identifier, String separator, String value)
{
long idFolder = 0;
Boolean ascending = true;
cookieRepository item = new cookieRepository();
item.Repository = identifier;
item.Type = FolderType.standard;
item.ItemsOrderBy = OrderBy.name;
if (!String.IsNullOrEmpty(value))
{
try{
List <String> values = value.Split(separator.ToCharArray()).ToList();
long.TryParse(values[0], out idFolder);
item.Type = lm.Comol.Core.DomainModel.Helpers.EnumParser <FolderType> .GetByString(values[1], FolderType.standard);
item.ItemsOrderBy = lm.Comol.Core.DomainModel.Helpers.EnumParser <OrderBy> .GetByString(values[2], OrderBy.name);
Boolean.TryParse(values[3], out ascending);
item.IdentifierPath = values[4];
item.IdFolder = idFolder;
item.Ascending = ascending;
return(item);
}
catch (Exception ex) {
return(null);
}
}
return(null);
}
public List <dtoDisplayRepositoryItem> GetAvailableRepositoryItems(
liteRepositorySettings settings,
Int32 idCurrentPerson,
RepositoryType type,
Int32 idCommunity,
String unknownUser,
Dictionary <FolderType, String> fTranslations,
Dictionary <ItemType, String> iTranslations,
ModuleRepository permissions,
Boolean forAdmin = false,
Boolean alsoHidden = false,
Boolean onlyFolder = false,
Boolean useCache = true)
{
return(GetAvailableRepositoryItems(
settings,
idCurrentPerson,
RepositoryIdentifier.Create(type, idCommunity),
unknownUser,
fTranslations,
iTranslations,
permissions,
forAdmin,
alsoHidden,
onlyFolder,
useCache));
}
public dtoDisplayVersionItem(liteRepositoryItemVersion version)
{
Permissions = new VersionPermission();
Repository = new RepositoryIdentifier();
Id = version.Id;
CreatedOn = version.CreatedOn;
Availability = version.Availability;
IsDeleted = version.Deleted != DomainModel.BaseStatusDeleted.None;
DisplayMode = version.DisplayMode;
Downloaded = version.Downloaded;
Extension = version.Extension;
IdCommunity = version.IdCommunity;
IdItem = version.IdItem;
IdCreatedBy = version.IdCreatedBy;
IdModifiedBy = version.IdModifiedBy;
IsActive = version.IsActive;
ModifiedOn = version.ModifiedOn;
Name = version.Name;
Number = version.Number;
Size = version.Size;
Status = version.Status;
Thumbnail = version.Thumbnail;
AutoThumbnail = version.AutoThumbnail;
Repository = version.Repository;
Type = version.Type;
UniqueIdItem = version.UniqueIdItem;
UniqueIdVersion = version.UniqueIdVersion;
Url = version.Url;
}
protected RepositoriesViewModel(IApplicationService applicationService)
{
applicationService = applicationService ?? Locator.Current.GetService <IApplicationService>();
Title = "Repositories";
var showDescription = applicationService.Account.RepositoryDescriptionInList;
var repositories = new ReactiveList <Repository>(resetChangeThreshold: 10);
Items = repositories.CreateDerivedCollection(x =>
{
var description = showDescription ? x.Description : string.Empty;
var viewModel = new RepositoryItemViewModel(x.Name, description, x.Owner?.Username, new Avatar(x.Owner?.Links?.Avatar?.Href));
viewModel.GoToCommand.Subscribe(_ =>
{
var id = RepositoryIdentifier.FromFullName(x.FullName);
NavigateTo(new RepositoryViewModel(id.Owner, id.Name, x));
});
return(viewModel);
}, x => x.Name.ContainsKeyword(SearchText), signalReset: this.WhenAnyValue(x => x.SearchText));
LoadCommand = ReactiveCommand.CreateFromTask(async _ =>
{
repositories.Clear();
await Load(applicationService, repositories);
});
LoadCommand.IsExecuting.CombineLatest(repositories.IsEmptyChanged, (x, y) => !x && y)
.ToProperty(this, x => x.IsEmpty, out _isEmpty);
}
public SourceTreeViewModel(IFeaturesService featuresService)
{
_featuresService = featuresService;
GoToItemCommand = ReactiveUI.ReactiveCommand.Create();
GoToItemCommand.OfType <ContentModel>().Subscribe(x =>
{
if (x.Type.Equals("dir", StringComparison.OrdinalIgnoreCase))
{
ShowViewModel <SourceTreeViewModel>(new NavObject {
Username = Username, Branch = Branch,
Repository = Repository, Path = x.Path, TrueBranch = TrueBranch
});
}
if (x.Type.Equals("file", StringComparison.OrdinalIgnoreCase))
{
if (x.DownloadUrl == null)
{
var nameAndSlug = x.GitUrl.Substring(x.GitUrl.IndexOf("/repos/", StringComparison.Ordinal) + 7);
var repoId = new RepositoryIdentifier(nameAndSlug.Substring(0, nameAndSlug.IndexOf("/git", StringComparison.Ordinal)));
var sha = x.GitUrl.Substring(x.GitUrl.LastIndexOf("/", StringComparison.Ordinal) + 1);
ShowViewModel <SourceTreeViewModel>(new NavObject {
Username = repoId.Owner, Repository = repoId.Name, Branch = sha
});
}
else
{
ShowViewModel <SourceViewModel>(new SourceViewModel.NavObject {
Name = x.Name, Username = Username, Repository = Repository, Branch = Branch,
Path = x.Path, HtmlUrl = x.HtmlUrl, GitUrl = x.GitUrl, TrueBranch = TrueBranch
});
}
}
});
}
protected BaseEventsViewModel(IApplicationService applicationService)
{
ApplicationService = applicationService;
var events = new ReactiveList <EventModel>();
Events = events.CreateDerivedCollection(CreateEventTextBlocks);
ReportRepository = true;
GoToRepositoryCommand = ReactiveCommand.Create();
GoToRepositoryCommand.OfType <EventModel.RepoModel>().Subscribe(x =>
{
var repoId = new RepositoryIdentifier(x.Name);
var vm = CreateViewModel <RepositoryViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
ShowViewModel(vm);
});
GoToGistCommand = ReactiveCommand.Create();
GoToGistCommand.OfType <EventModel.GistEvent>().Subscribe(x =>
{
var vm = CreateViewModel <GistViewModel>();
vm.Id = x.Gist.Id;
vm.Gist = x.Gist;
ShowViewModel(vm);
});
LoadCommand = ReactiveCommand.CreateAsyncTask(t =>
this.RequestModel(CreateRequest(0, 100), t as bool?, response =>
{
//this.CreateMore(response, m => { }, events.AddRange);
events.Reset(response.Data);
}));
}
public Boolean StatisticsAddPlay(Int32 idPerson, RepositoryIdentifier rIdentifier, long idItem, Guid uniqueIdItem, long idVersion, Guid uniqueIdVersion, ItemType type, Int32 idCommunity, long idAction, String playSessionId)
{
Boolean result = false;
try
{
PlayStatistics stat = new PlayStatistics();
stat.CreatedIPaddress = UC.IpAddress;
stat.CreatedOn = DateTime.Now;
stat.CreatedProxyIPaddress = UC.ProxyIpAddress;
stat.WorkingSessionID = playSessionId;
stat.IdAction = idAction;
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);
}
catch (Exception ex)
{
}
return(result);
}
public void AddCommunityFilesToItem(long idActivity, RepositoryIdentifier identifier)
{
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
else
{
List <lm.Comol.Core.FileRepository.Domain.dtoModuleUploadedItem> files = null;
Activity activity = Service.GetActivity(idActivity);
if (activity != null)
{
files = View.UploadFiles(ModuleEduPath.UniqueCode, (Int32)ModuleEduPath.ObjectType.SubActivity, (Int32)ModuleEduPath.ActionType.DoSubActivity, true);
}
else
{
View.DisplayActivityNotFound();
return;
}
if (files != null && files.Any(f => f.IsAdded))
{
AddCommunityFilesToItem(activity, identifier, (files == null) ? null : files.Where(f => f.IsAdded).Select(f => f.Link).ToList());
}
else
{
View.DisplayNoFilesToAdd();
}
}
}
private void PinRepository()
{
var repoInfo = RepositoryIdentifier.FromFullName(Repository.FullName);
//Is it pinned already or not?
var pinnedRepo = _applicationService.Account.PinnedRepositories.Find(
x => string.Equals(x.Owner, repoInfo.Owner, StringComparison.OrdinalIgnoreCase) &&
string.Equals(x.Slug, repoInfo.Name, StringComparison.OrdinalIgnoreCase));
if (pinnedRepo == null)
{
var avatar = new Avatar(Repository.Links.Avatar.Href).ToUrl();
_applicationService.Account.PinnedRepositories.Add(new Data.PinnedRepository
{
Owner = repoInfo.Owner,
Slug = repoInfo.Name,
ImageUri = avatar,
Name = repoInfo.Name
});
}
else
{
_applicationService.Account.PinnedRepositories.RemoveAll(x => x.Id == pinnedRepo.Id);
}
}
private List <DisplayRepositoryAction> GetAvailableActions(RepositoryIdentifier identifier, ModuleRepository module)
{
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
List <DisplayRepositoryAction> actions = new List <DisplayRepositoryAction>();
if ((module.Administration || module.ManageItems || module.UploadFile) && identifier.Type == RepositoryType.Community && identifier.IdCommunity > 0)
{
actions.Add(DisplayRepositoryAction.repositoryDownloadOrPlay);
}
if (module.Administration || module.ManageItems || module.UploadFile || module.ViewItemsList || module.DownloadOrPlay)
{
List <lm.Comol.Core.FileRepository.Domain.ItemType> availableTypes = ServiceRepository.GetAvailableTypes(identifier, module, UserContext.CurrentUserID);
if (availableTypes.Contains(lm.Comol.Core.FileRepository.Domain.ItemType.File))
{
actions.Add(DisplayRepositoryAction.downloadItem);
}
if (availableTypes.Contains(lm.Comol.Core.FileRepository.Domain.ItemType.Multimedia))
{
actions.Add(DisplayRepositoryAction.playMultimedia);
}
if (availableTypes.Contains(lm.Comol.Core.FileRepository.Domain.ItemType.ScormPackage))
{
actions.Add(DisplayRepositoryAction.playScormPackage);
}
}
actions.Add(DisplayRepositoryAction.internalDownloadOrPlay);
return(actions);
}
private void InitializeSelectors(RepositoryIdentifier identifier, List <Int32> removeRoles, List <Int32> removeUsers)
{
Boolean allowAddRole = identifier.Type == RepositoryType.Community;
Boolean allowAddUsers = true;
if (allowAddRole)
{
List <lm.Comol.Core.DomainModel.dtoTranslatedRoleType> roles = CurrentManager.GetTranslatedRoles(identifier.IdCommunity, UserContext.Language.Id).Where(r => !removeRoles.Contains(r.Id)).ToList();
allowAddRole = (roles != null && roles.Any());
View.InitializeRolesSelector(roles);
}
if (allowAddUsers)
{
switch (identifier.Type)
{
case RepositoryType.Community:
View.InitializeUsersSelector(identifier.IdCommunity, removeUsers);
break;
case RepositoryType.Portal:
View.InitializePortalUsersSelector(removeUsers);
break;
default:
allowAddUsers = false;
break;
}
}
View.InitializeCommands(allowAddRole, allowAddUsers);
}
public ScormPackageSettings(String packagePath, Boolean isValid = true)
{
Repository = new RepositoryIdentifier();
PackagePath = packagePath;
Organizations = new List <ScormOrganizationSettings>();
IsValid = isValid;
}
public void InitView(Boolean allowPaging, Boolean selectAll, Int32 pageSize, RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems = null, OrderBy orderBy = OrderBy.name, Boolean ascending = true)
{
if (SessionTimeout())
{
return;
}
View.IdUserLoader = UserContext.CurrentUserID;
View.AvailableTypes = typesToLoad;
View.CurrentAvailability = availability;
View.IdRemovedItems = idRemovedItems;
View.LoadForModule = false;
View.ModuleCode = ModuleRepository.UniqueCode;
View.RepositoryIdentifier = identifier;
View.CurrentOrderBy = orderBy;
View.CurrentAscending = ascending;
View.isInitialized = true;
View.CurrentAdminMode = adminMode;
View.CurrentShowHiddenItems = showHiddenItems;
View.CurrentDisableNotAvailableItems = disableNotAvailableItems;
if (!typesToLoad.Any(t => t == ItemType.Multimedia || t == ItemType.ScormPackage || t == ItemType.VideoStreaming))
{
displayStatistics.Remove(StatisticType.plays);
displayStatistics.Remove(StatisticType.myplays);
}
if (!typesToLoad.Any(t => t != ItemType.Folder && t != ItemType.Link))
{
displayStatistics.Remove(StatisticType.downloads);
displayStatistics.Remove(StatisticType.mydownloads);
}
View.DisplayStatistics = displayStatistics;
LoadItems(Service.GetPermissions(identifier, UserContext.CurrentUserID), UserContext.CurrentUserID, allowPaging, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems, selectAll, orderBy, ascending, 0, pageSize);
}
public void LoadItems(RepositoryIdentifier identifier, Boolean adminMode, Boolean showHiddenItems, Boolean disableNotAvailableItems, List <ItemType> typesToLoad, ItemAvailability availability, List <StatisticType> displayStatistics, List <long> idRemovedItems, List <long> idSelectedItems, Boolean selectAll, OrderBy orderBy, Boolean ascending, Int32 pageIndex, Int32 pageSize)
{
if (!SessionTimeout())
{
LoadItems(Service.GetPermissions(identifier, UserContext.CurrentUserID), UserContext.CurrentUserID, true, identifier, adminMode, showHiddenItems, disableNotAvailableItems, typesToLoad, availability, displayStatistics, idRemovedItems, idSelectedItems, selectAll, orderBy, ascending, pageIndex, pageSize);
}
}
public List <dtoRepositoryItemToSelect> GetSelectedItems(RepositoryIdentifier identifier, Boolean adminMode, List <StatisticType> displayStatistics, List <ItemType> typesToLoad, List <long> idSelectedItems, Boolean selectAll)
{
if (!SessionTimeout())
{
Dictionary <Boolean, List <long> > selections = View.GetCurrentSelection();
idSelectedItems = idSelectedItems.Except(selections[false]).ToList();
idSelectedItems.AddRange(selections[true]);
if (idSelectedItems.Any())
{
idSelectedItems = idSelectedItems.Distinct().ToList();
}
View.IdSelectedItems = idSelectedItems;
if (selectAll)
{
return(Service.ItemsToSelectGet(View.IdUserLoader, "/", Service.GetPermissions(identifier, UserContext.CurrentUserID), identifier, adminMode, View.CurrentShowHiddenItems, View.CurrentDisableNotAvailableItems, typesToLoad, View.CurrentAvailability, displayStatistics, View.IdRemovedItems, idSelectedItems, selectAll, !typesToLoad.Contains(ItemType.Folder)).Where(i => i.Selectable && i.Selected).ToList());
}
else
{
return(Service.ItemsToSelectGet(UserContext.CurrentUserID, "/", Service.GetPermissions(identifier, UserContext.CurrentUserID), identifier, adminMode, displayStatistics, idSelectedItems));
}
}
else
{
return(new List <dtoRepositoryItemToSelect>());
}
}
public liteRepositorySettings SettingsGetByRepositoryIdentifier(RepositoryIdentifier item)
{
liteRepositorySettings result = null;
if (item != null)
{
try
{
switch (item.Type)
{
case RepositoryType.Portal:
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal)));
break;
default:
Int32 idOrganization = Manager.GetIdOrganizationFromCommunity(item.IdCommunity);
result = SettingsGetDefault(SettingsGet(s => s.Deleted == DomainModel.BaseStatusDeleted.None && s.Status == ItemStatus.Active && (s.Type == SettingsType.Istance || s.Type == SettingsType.Portal || (s.Type == SettingsType.Organization && s.IdOrganization == idOrganization) || (s.Type == SettingsType.Community && s.IdCommunity == item.IdCommunity))));
break;
}
}
catch (Exception ex)
{
}
}
return(result);
}
private void GoToCommits(EventModel.RepoModel repoModel, string branch)
{
var repoId = new RepositoryIdentifier(repoModel.Name);
var vm = this.CreateViewModel <CommitsViewModel>();
NavigateTo(vm.Init(repoId.Owner, repoId.Name, branch));
}
public void InitView(RepositoryIdentifier identifier, long idActivity, List <long> unloadItems = null)
{
View.Identifier = identifier;
unloadItems = unloadItems ?? new List <long>();
View.UnloadItems = unloadItems;
View.CurrentAction = DisplayRepositoryAction.none;
View.IdActivity = idActivity;
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
else
{
ModuleRepository module = ServiceRepository.GetPermissions(identifier, UserContext.CurrentUserID);
List <DisplayRepositoryAction> actions = GetAvailableActions(identifier, module);
View.LoadAvailableActions(actions, DisplayRepositoryAction.select);
if (actions.Any())
{
if (actions.Contains(DisplayRepositoryAction.repositoryDownloadOrPlay))
{
View.InitializeCommunityUploader(identifier);
}
View.InitializeInternalUploader(identifier);
}
}
}
public void ChangeAction(long idActivity, RepositoryIdentifier identifier, DisplayRepositoryAction action, List <long> unloadItems)
{
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired(identifier.IdCommunity, CurrentIdModule);
}
else
{
switch (action)
{
case DisplayRepositoryAction.playMultimedia:
case DisplayRepositoryAction.downloadItem:
case DisplayRepositoryAction.playScormPackage:
ModuleRepository module = ServiceRepository.GetPermissions(identifier, UserContext.CurrentUserID);
switch (action)
{
case DisplayRepositoryAction.downloadItem:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.File);
break;
case DisplayRepositoryAction.playMultimedia:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.Multimedia);
break;
case DisplayRepositoryAction.playScormPackage:
View.InitializeLinkRepositoryItems(UserContext.CurrentUserID, module, identifier, unloadItems, lm.Comol.Core.FileRepository.Domain.ItemType.ScormPackage);
break;
}
break;
}
View.DisplayAction(action);
}
}
public void LoadAssignments(Boolean editMode, long idItem, Dictionary <AssignmentType, String> tTranslations, Dictionary <PermissionsTranslation, String> translations, Dictionary <ModuleRepository.Base2Permission, String> pTranslations, List <dtoEditAssignment> assignments = null)
{
RepositoryIdentifier identifier = Service.ItemGetRepositoryIdentifier(idItem);
if (identifier != null)
{
List <dtoEditAssignment> items = Service.ItemGetAssignmentsForEditing(idItem, tTranslations, translations, pTranslations);
if (assignments != null && items != null)
{
foreach (dtoEditAssignment i in items.Where(x => !x.Inherited && assignments.Any(a => a.Id == x.Id && a.Type == x.Type && a.Denyed != x.Denyed)))
{
i.Denyed = assignments.Any(a => a.Id == i.Id && a.Denyed);
}
foreach (dtoEditAssignment nItem in items.Where(i => !i.Inherited && !assignments.Any(a => a.Id == i.Id)))
{
switch (nItem.Type)
{
case AssignmentType.community:
dtoEditAssignment vItem = assignments.Where(a => a.Type == nItem.Type).FirstOrDefault();
if (vItem != null && !vItem.Denyed && nItem.Denyed)
{
nItem.Denyed = false;
}
assignments = assignments.Where(a => a.Type != AssignmentType.community).ToList();
break;
case AssignmentType.person:
dtoEditAssignment pItem = assignments.Where(a => a.Type == nItem.Type && a.IdPerson == nItem.IdPerson).FirstOrDefault();
if (pItem != null && !pItem.Denyed && nItem.Denyed)
{
nItem.Denyed = false;
}
assignments = assignments.Where(a => a.Type != nItem.Type && a.IdPerson != nItem.IdPerson).ToList();
break;
case AssignmentType.role:
dtoEditAssignment rItem = assignments.Where(a => a.Type == nItem.Type && a.IdRole == nItem.IdRole).FirstOrDefault();
if (rItem != null && !rItem.Denyed && nItem.Denyed)
{
nItem.Denyed = false;
}
assignments = assignments.Where(a => a.Type != nItem.Type && a.IdRole != nItem.IdRole).ToList();
break;
}
}
assignments.AddRange(items.Where(i => !assignments.Any(a => a.Id == i.Id)).ToList());
assignments = assignments.OrderBy(a => a.OrderByInherited()).ThenBy(a => a.OrderByType()).ThenBy(a => a.DisplayName).ToList();
InitializeSelectors(identifier, assignments.Select(i => i.IdRole).ToList(), assignments.Where(a => a.IdPerson > 0).Select(i => i.IdPerson).ToList());
View.LoadAssignments(assignments);
}
else if (items != null)
{
InitializeSelectors(identifier, items.Select(i => i.IdRole).ToList(), items.Where(a => a.IdPerson > 0).Select(i => i.IdPerson).ToList());
View.LoadAssignments(items.OrderBy(a => a.OrderByInherited()).ThenBy(a => a.OrderByType()).ThenBy(a => a.DisplayName).ToList());
}
}
}
private void GoToRepository(EventModel.RepoModel repo)
{
var repoId = new RepositoryIdentifier(repo.Name);
var vm = this.CreateViewModel <RepositoryViewModel>();
vm.Init(repoId.Owner, repoId.Name);
NavigateTo(vm);
}
protected virtual void GoToCommit(CommitModel x)
{
var repo = new RepositoryIdentifier(x.Repository.FullName);
ShowViewModel <CommitViewModel>(new CommitViewModel.NavObject {
Username = repo.Owner, Repository = repo.Name, Node = x.Hash
});
}
private void GoToBranches(RepositoryIdentifier repoId)
{
ShowViewModel <BranchesAndTagsViewModel>(new BranchesAndTagsViewModel.NavObject
{
Username = repoId.Owner,
Repository = repoId.Name,
IsShowingBranches = true
});
}
private void GoToBranches(RepositoryIdentifier repoId)
{
var vm = this.CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
vm.SelectedFilter = BranchesAndTagsViewModel.ShowIndex.Branches;
NavigateTo(vm);
}
public List <dtoItemToDelete> RepositoryPhisicalDelete(RepositoryIdentifier identifier, String basePath, String thumbnailPath)
{
List <dtoItemToDelete> itemsToDelete = new List <dtoItemToDelete>();
try
{
List <String> filesToDelete = new List <string>();
List <liteRepositoryItem> items = GetQuery(identifier).Where(i => !i.IsInternal).ToList();
List <liteRepositoryItemVersion> versions = GetQueryVersions(identifier).ToList();
versions = versions.Where(v => items.Any(i => i.Id == v.IdItem)).ToList();
List <ItemAssignments> assignments = GetQueryAssignments(identifier).ToList();
List <liteFileTransfer> mTransfer = FileTransferGetById(items.Where(i => i.Type == ItemType.ScormPackage || i.Type == ItemType.Multimedia).Select(i => i.Id).ToList());
Manager.BeginTransaction();
Manager.DeletePhysicalList(assignments);
Manager.DeletePhysicalList(mTransfer);
foreach (liteRepositoryItem i in items.Where(v => v.Type == ItemType.Multimedia))
{
List <MultimediaFileObject> mObjects = (from m in Manager.GetIQ <MultimediaFileObject>() where m.IdItem == i.Id select m).ToList();
if (mObjects != null && mObjects.Any())
{
Manager.DeletePhysicalList(mObjects);
}
}
foreach (liteRepositoryItem i in items.Where(v => v.Type == ItemType.ScormPackage))
{
List <lm.Comol.Core.FileRepository.Domain.ScormSettings.ScormPackageSettings> mObjects = (from m in Manager.GetIQ <lm.Comol.Core.FileRepository.Domain.ScormSettings.ScormPackageSettings>() where m.IdItem == i.Id select m).ToList();
if (mObjects != null && mObjects.Any())
{
Manager.DeletePhysicalList(mObjects);
}
}
String path = GetItemDiskPath(basePath, identifier);
String pathThumbnail = GetItemDiskPath(thumbnailPath, identifier);
filesToDelete.AddRange(versions.Where(v => v.Type != ItemType.Folder && v.Type != ItemType.Link).Select(v => System.IO.Path.Combine(path, v.UniqueIdVersion.ToString() + v.Extension)).ToList());
filesToDelete.AddRange(versions.Where(v => !String.IsNullOrEmpty(v.Thumbnail)).Select(v => System.IO.Path.Combine(pathThumbnail, v.Thumbnail)).ToList());
itemsToDelete = items.Select(i => new dtoItemToDelete(i)).ToList();
Manager.DeletePhysicalList(versions);
Manager.DeletePhysicalList(items);
Manager.Commit();
if (filesToDelete.Any())
{
lm.Comol.Core.File.Delete.Files(filesToDelete);
}
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.Repository(identifier));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersViewOfRepository(identifier));
lm.Comol.Core.DomainModel.Helpers.CacheHelper.PurgeCacheItems(CacheKeys.UsersSizeViewOfRepository(identifier));
}
catch (Exception ex) {
Manager.RollBack();
itemsToDelete = null;
}
return(itemsToDelete);
}
private void GoToBranch(RepositoryIdentifier repoId, string branchName)
{
if (repoId == null)
{
return;
}
GoToBranchCommand.OnNext(Tuple.Create(repoId, branchName));
}
private void GoToRepository(EventModel.RepoModel eventModel)
{
var repoId = new RepositoryIdentifier(eventModel.Name);
ShowViewModel <RepositoryViewModel>(new RepositoryViewModel.NavObject
{
Username = repoId.Owner,
Repository = repoId.Name
});
}
private void GoToTags(EventModel.RepoModel eventModel)
{
var repoId = new RepositoryIdentifier(eventModel.Name);
var vm = this.CreateViewModel <BranchesAndTagsViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
vm.SelectedFilter = BranchesAndTagsViewModel.ShowIndex.Tags;
NavigateTo(vm);
}
private void GoToCommits(EventModel.RepoModel repoModel, string branch)
{
var repoId = new RepositoryIdentifier(repoModel.Name);
var vm = this.CreateViewModel <CommitsViewModel>();
vm.RepositoryOwner = repoId.Owner;
vm.RepositoryName = repoId.Name;
vm.Branch = branch;
NavigateTo(vm);
}
