public void AddCommunityFilesToItem(long idEvent, long idEventItem, Int32 idCommunity, Boolean visibleForItem, Boolean visibleForRepository)
{
if (UserContext.isAnonymous)
{
View.DisplayWorkingSessionExpired();
}
else
{
List <lm.Comol.Core.FileRepository.Domain.dtoModuleUploadedItem> files = null;
CommunityEventItem item = Service.EventItemGet(idEventItem);
if (item != null)
{
files = View.UploadFiles(ModuleCommunityDiary.UniqueID, (Int32)ModuleCommunityDiary.ObjectType.DiaryItemLinkedFile, (Int32)ModuleCommunityDiary.ActionType.DownloadFileItem, true);
}
else
{
View.DisplayEventItemNotFound();
View.SendUserAction(idCommunity, CurrentIdModule, idEventItem, ModuleCommunityDiary.ActionType.UnkownDiaryItem);
return;
}
if (files != null && files.Any(f => f.IsAdded))
{
AddCommunityFilesToItem(idEvent, idEventItem, idCommunity, (files == null) ? null : files.Where(f => f.IsAdded).Select(f => f.Link).ToList(), visibleForItem, visibleForRepository);
}
else
{
View.DisplayNoFilesToAdd();
}
}
}
private dtoDiaryItem CreateDtoDiaryItem(litePerson person, CommunityEventItem item, Boolean viewAlsoDeleted, ModuleCommunityDiary module, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository, ref int lessionID, List <lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions> actions, lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions dAction, String unknownUser)
{
dtoDiaryItem dtoItem = new dtoDiaryItem();
dtoItem.CommunityId = item.IdCommunityOwner;
DescriptionEventItem dObject = EventItemGetDescriptionObject(item.Id);
if (dObject != null)
{
dtoItem.Description = dObject.Description;
dtoItem.DescriptionPlain = dObject.DescriptionPlain;
}
else
{
dtoItem.Description = "";
dtoItem.DescriptionPlain = "";
}
dtoItem.EventItem = item;
dtoItem.Permission = GetItemPermission(person, item, module, moduleRepository);
dtoItem.UploadActions = actions;
dtoItem.DefaultUploadAction = dAction;
dtoItem.Attachments = AttachmentsGet(person, item, viewAlsoDeleted, dtoItem.Permission, moduleRepository, unknownUser).Where(a => a.Attachment.File != null && a.Attachment.File.IsValid).ToList();
dtoItem.Id = item.Id;
dtoItem.IdEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
dtoItem.LessonNumber = lessionID;
lessionID += 1;
return(dtoItem);
}
public void UnlinkRepositoryItem(long idItem, long idAttachment, Int32 idCommunity, String unknownUser)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
litePerson person = CurrentManager.GetLitePerson(UserContext.CurrentUserID);
if (person == null || person.Id == 0)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
ModuleCommunityDiary module = Service.GetPermissions(UserContext.CurrentUserID, idCommunity);
CommunityEventItem item = Service.EventItemGet(idItem);
EventItemFile attachment = Service.EventItemGetAttachment(idAttachment);
if (item != null && attachment != null)
{
Service.UnLinkAttachment(idAttachment, person);
ReloadAttachments(person, item, module, View.RepositoryIdentifier, unknownUser);
}
else if (item != null)
{
ReloadAttachments(person, item, module, View.RepositoryIdentifier, unknownUser);
}
else
{
View.LoadAttachments(null);
}
}
}
}
private CommunityEventItem SaveDiaryItem(Int32 idCommunity, long idItem, CommunityEventItem dto, String description, String descriptionPlain)
{
CommunityEventItem previousItem = null;
CommunityEventItem savedItem = null;
bool NotifyEdit = false;
if (dto.StartDate > dto.EndDate)
{
dto.EndDate = (dto.ShowDateInfo ? dto.StartDate : dto.StartDate.AddHours(2));
}
DateTime oldStartDate = dto.StartDate;
DateTime oldEndDate = dto.EndDate;
if (idItem == 0)
{
dto.Id = 0;
}
else
{
dto.Id = idItem;
previousItem = Service.EventItemGet(idItem);
if (previousItem != null)
{
oldStartDate = previousItem.StartDate;
oldEndDate = previousItem.EndDate;
}
NotifyEdit = previousItem.Note != dto.Note || Service.EventItemGetDescription(previousItem) != description || previousItem.Title != dto.Title || previousItem.StartDate != dto.StartDate || previousItem.EndDate != dto.EndDate || previousItem.Place != dto.Place || previousItem.Link != dto.Link;
}
CommunityEventType type = Service.GetDiaryEventType();
return(Service.SaveEventItem(idCommunity, dto, description, descriptionPlain, UserContext.CurrentUser.Id, UserContext.CurrentUser.Id, type));
}
public void SaveItem(Int32 idCommunity, long idItem, CommunityEventItem dto, DateTime startDate, DateTime endDate, List <dtoWeekDay> weekDays, String description, String descriptionPlain)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
CommunityEventType type = Service.GetDiaryEventType();
CommunityEvent eventObj = Service.AddMultipleItems(idCommunity, dto, description, descriptionPlain, UserContext.CurrentUserID, type, startDate, endDate, weekDays);
if (eventObj == null)
{
View.SetBackToDiary(idCommunity, 0);
}
else if (eventObj.Items != null && eventObj.Items.Count > 0)
{
View.SendToItemsList(idCommunity, eventObj.Items.FirstOrDefault().Id);
}
else
{
View.SetBackToDiary(idCommunity, 0);
}
}
}
private CommunityEvent CreateGenericEvent(Int32 idCommunity, CommunityEventItem item, CommunityEventType eventType, litePerson person)
{
CommunityEvent oEventItem = new CommunityEvent();
oEventItem.IdCommunityOwner = idCommunity;
oEventItem.ForEver = false;
oEventItem.IsMacro = false;
oEventItem.IsRepeat = false;
oEventItem.IsVisible = item.IsVisible;
oEventItem.Items = new List <CommunityEventItem>();
oEventItem.Link = item.Link;
if (item.ModifiedOn.Equals(DateTime.MinValue))
{
oEventItem.ModifiedOn = DateTime.Now;
item.ModifiedOn = oEventItem.ModifiedOn;
}
else
{
oEventItem.ModifiedOn = item.ModifiedOn;
}
oEventItem.Name = "";
////DiaryItem.Title
oEventItem.Note = item.Note;
oEventItem.NotePlain = item.NotePlain;
oEventItem.Owner = person;
oEventItem.Place = item.Place;
oEventItem.Year = item.StartDate.Year;
oEventItem.EventType = eventType;
if (item.StartDate.Month < 9)
{
oEventItem.Year = oEventItem.Year - 1;
}
return(oEventItem);
}
public void PhisicalDelete(long idItem, long idAttachment, Int32 idCommunity, String baseFilePath, String baseThumbnailPath, String unknownUser)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(View.IdCommunityDiary);
}
else
{
litePerson person = CurrentManager.GetLitePerson(UserContext.CurrentUserID);
if (person == null || person.Id == 0)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
ModuleCommunityDiary module = Service.GetPermissions(UserContext.CurrentUserID, idCommunity);
CommunityEventItem item = Service.EventItemGet(idItem);
EventItemFile attachment = Service.EventItemGetAttachment(idAttachment);
if (item != null && attachment != null)
{
if (module.Edit || module.Administration)
{
Service.AttachmentPhisicalDelete(item, attachment, baseFilePath, baseThumbnailPath);
}
ReloadAttachments(person, item, module, View.RepositoryIdentifier, unknownUser);
}
else if (item != null)
{
ReloadAttachments(person, item, module, View.RepositoryIdentifier, unknownUser);
}
}
}
}
public Boolean UnLinkAttachment(long idAttachment, litePerson person)
{
Boolean unlinked = false;
EventItemFile attachment = Manager.Get <EventItemFile>(idAttachment);
if (person != null && person.Id > 0 && attachment != null && (attachment.Item == null || !attachment.Item.IsInternal))
{
try
{
CommunityEventItem item = Manager.Get <CommunityEventItem>(attachment.IdItemOwner);
Manager.BeginTransaction();
if (item != null)
{
item.ModifiedBy = person;
item.ModifiedOn = DateTime.Now;
Manager.SaveOrUpdate(item);
}
Manager.DeleteGeneric(attachment);
Manager.Commit();
unlinked = true;
}
catch (Exception ex)
{
Manager.RollBack();
}
}
return(unlinked);
}
private void AttachmentsSetVirtualDelete(List <long> idAttachments, Boolean delete)
{
litePerson person = Manager.GetLitePerson(UC.CurrentUserID);
List <EventItemFile> attachments = (from f in Manager.Linq <EventItemFile>() where idAttachments.Contains(f.Id) select f).ToList();
if (person != null && attachments.Count > 0)
{
List <CommunityEventItem> items = EventItemsGet(attachments.Select(f => f.IdCommunity).FirstOrDefault(), attachments.Select(f => f.IdItemOwner).Distinct().ToList());
try
{
Manager.BeginTransaction();
foreach (EventItemFile attachment in attachments)
{
attachment.UpdateMetaInfo(person, UC.IpAddress, UC.ProxyIpAddress);
attachment.Deleted = delete ? BaseStatusDeleted.Manual : BaseStatusDeleted.None;
CommunityEventItem item = items.Where(i => i.Id == attachment.IdItemOwner).FirstOrDefault();
if (item != null)
{
item.ModifiedBy = attachment.ModifiedBy;
item.ModifiedOn = attachment.ModifiedOn.Value;
Manager.SaveOrUpdate(item);
}
Manager.SaveOrUpdate(attachment);
}
Manager.Commit();
}
catch (Exception ex)
{
Manager.RollBack();
}
}
}
private void AttachmentSetVirtualDelete(long idAttachment, Boolean delete)
{
litePerson person = Manager.GetLitePerson(UC.CurrentUserID);
EventItemFile attachment = Manager.Get <EventItemFile>(idAttachment);
if (person != null && attachment != null)
{
try
{
Manager.BeginTransaction();
attachment.UpdateMetaInfo(person, UC.IpAddress, UC.ProxyIpAddress);
attachment.Deleted = delete ? BaseStatusDeleted.Manual : BaseStatusDeleted.None;
CommunityEventItem item = EventItemGet(attachment.IdItemOwner);
if (item != null)
{
item.ModifiedBy = attachment.ModifiedBy;
item.ModifiedOn = attachment.ModifiedOn.Value;
Manager.SaveOrUpdate(item);
}
Manager.SaveOrUpdate(attachment);
Manager.Commit();
}
catch (Exception ex)
{
Manager.RollBack();
}
}
}
public CommunityEvent AddMultipleItems(Int32 idCommunity, CommunityEventItem dtoItem, String description, String descriptionPlain, int ownerId, CommunityEventType eventType, DateTime startDate, DateTime endDate, List <dtoWeekDay> weekDays)
{
CommunityEvent communityEvent = null;
try
{
litePerson person = Manager.GetLitePerson(ownerId);
liteCommunity community = Manager.GetLiteCommunity(idCommunity);
if ((community != null && idCommunity > 0) && person != null)
{
List <dtoWeekDayRecurrence> itemsToInsert = dtoWeekDayRecurrence.CreateRecurrency(startDate, endDate, weekDays);
if (itemsToInsert.Count > 0)
{
Manager.BeginTransaction();
communityEvent = CreateGenericEvent(idCommunity, dtoItem, eventType, person);
Manager.SaveOrUpdate(communityEvent);
foreach (dtoWeekDayRecurrence recurrence in itemsToInsert)
{
CommunityEventItem eventItem = new CommunityEventItem()
{
IdCommunityOwner = idCommunity, EventOwner = communityEvent, Owner = person, CreatedBy = person, CreatedOn = DateTime.Now
};
eventItem.ModifiedBy = eventItem.CreatedBy;
eventItem.ModifiedOn = eventItem.CreatedOn;
eventItem.Note = dtoItem.Note;
eventItem.NotePlain = dtoItem.NotePlain;
eventItem.Place = dtoItem.Place;
eventItem.Title = dtoItem.Title;
eventItem.StartDate = recurrence.StartDate;
eventItem.EndDate = recurrence.EndDate;
eventItem.ShowDateInfo = dtoItem.ShowDateInfo;
eventItem.IsVisible = dtoItem.IsVisible;
eventItem.Link = dtoItem.Link;
eventItem.AllowEdit = true;
Manager.SaveOrUpdate(eventItem);
if (!String.IsNullOrEmpty(description))
{
DescriptionEventItem descriptionItem = new DescriptionEventItem()
{
Id = eventItem.Id, Description = description
};
descriptionItem.DescriptionPlain = descriptionPlain;
Manager.SaveOrUpdate(descriptionItem);
}
communityEvent.Items.Add(eventItem);
}
Manager.SaveOrUpdate(communityEvent);
Manager.Commit();
}
}
}
catch (Exception ex)
{
Manager.RollBack();
communityEvent = null;
}
return(communityEvent);
}
private void DisplayEventItemInfo(long idEventItem, Int32 lessonNumber)
{
CommunityEventItem item = Service.EventItemGet(idEventItem);
if (item != null)
{
View.DisplayEventItemInfo(item.Title, item.StartDate, item.EndDate, item.ShowDateInfo, item.MinutesDuration, lessonNumber);
}
}
private void DeleteItem(Int32 idCommunity, ModuleCommunityDiary module, CommunityEventItem item, long idItem, String baseFilePath, String baseThumbnailPath)
{
if (item != null && (module.Administration || module.DeleteItem))
{
DateTime startDate = item.StartDate;
DateTime endDate = item.EndDate;
Boolean isVisible = item.IsVisible;
Service.PhisicalDeleteItem(item, baseFilePath, baseThumbnailPath);
}
}
private List <dtoAttachment> AttachmentsGet(litePerson person, CommunityEventItem item, Boolean viewAlsoDeleted, String unknownUser)
{
List <dtoAttachment> items = (from fi in Manager.GetAll <EventItemFile>(fi => fi.IdItemOwner == item.Id && (viewAlsoDeleted || (!viewAlsoDeleted && fi.Deleted == BaseStatusDeleted.None)))
select new dtoAttachment(fi, unknownUser)).ToList();
List <dtoAttachment> orderedFiles = (from f in items where f.File == null || f.Link == null orderby f.CreatedOn select f).ToList();
orderedFiles.AddRange((from f in items where f.File != null && f.Link != null orderby f.File.DisplayName select f).ToList());
return(orderedFiles);
}
public dtoDiaryItem(CoreItemPermission module, CommunityEventItem item, List <RepositoryAttachmentUploadActions> actions, RepositoryAttachmentUploadActions dAction)
{
Id = item.Id;
EventItem = item;
CommunityId = item.IdCommunityOwner;
IdEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
Permission = module;
UploadActions = actions;
DefaultUploadAction = dAction;
Attachments = new List <dtoAttachmentItem>();
}
public Boolean AttachmentPhisicalDelete(CommunityEventItem item, EventItemFile attachment, String baseFilePath, String baseThumbnailPath)
{
Boolean result = (attachment == null);
if (item != null && attachment != null)
{
litePerson person = Manager.GetLitePerson(UC.CurrentUserID);
Boolean isInTransaction = Manager.IsInTransaction();
try
{
List <string> filesToRemove = new List <string>();
if (!isInTransaction)
{
Manager.BeginTransaction();
}
if (attachment.Item != null && attachment.Item.IsInternal)
{
filesToRemove.Add(ServiceRepository.GetItemDiskFullPath(baseFilePath, attachment.Item));
filesToRemove.Add(ServiceRepository.GetItemThumbnailFullPath(baseThumbnailPath, attachment.Item));
Manager.DeletePhysical(attachment.Item);
if (attachment.Version != null)
{
Manager.DeletePhysical(attachment.Version);
}
}
if (attachment.Link != null)
{
Manager.DeletePhysical(attachment.Link);
}
Manager.DeletePhysical(attachment);
item.ModifiedOn = DateTime.Now;
item.ModifiedBy = person;
Manager.SaveOrUpdate(item);
if (!isInTransaction)
{
Manager.Commit();
}
lm.Comol.Core.File.Delete.Files(filesToRemove);
}
catch (Exception ex)
{
if (!isInTransaction)
{
Manager.RollBack();
}
result = false;
}
}
return(result);
}
private void ReloadAttachments(litePerson person, CommunityEventItem item, ModuleCommunityDiary module, lm.Comol.Core.FileRepository.Domain.RepositoryIdentifier identifier, String unknownUser)
{
long idEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = ServiceRepository.GetPermissions(identifier, UserContext.CurrentUserID);
List <lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions> availableActions = Service.GetAvailableUploadActions(module, moduleRepository);
lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions dAction = (availableActions == null || !availableActions.Any()) ? lm.Comol.Core.DomainModel.Repository.RepositoryAttachmentUploadActions.none : availableActions.FirstOrDefault();
View.InitializeAttachmentsControl(idEvent, item.Id, availableActions, dAction);
View.LoadAttachments(Service.AttachmentsGet(person, item, true, Service.GetItemPermission(person, item, module, moduleRepository), moduleRepository, unknownUser));
}
public CommunityEventItem EventItemGet(long idItem)
{
CommunityEventItem oItem = null;
try
{
oItem = Manager.Get <CommunityEventItem>(idItem);
}
catch (Exception ex)
{
}
return(oItem);
}
private Boolean AllowViewDiaryItem(long idItem, Int32 idUser)
{
Boolean iResponse = false;
CommunityEventItem item = EventItemGet(idItem);
litePerson person = Manager.GetLitePerson(idUser);
if (item != null)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, item.IdCommunityOwner);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, item.IdCommunityOwner);
CoreItemPermission itemPermission = GetItemPermission(person, item, modulePermission, moduleRepository);
iResponse = (itemPermission.AllowView);
}
return(iResponse);
}
public void GetSavedItemData(Int32 idCommunity, long idItem)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
CommunityEventItem item = Service.EventItemGet(idItem);
if (item != null)
{
View.UpdateItemData(item.StartDate, item.EndDate);
}
}
}
public dtoDiaryItem(int idCommunity, CoreItemPermission module, CommunityEventItem item, Int32 lessonNumber, String description, List <RepositoryAttachmentUploadActions> actions, RepositoryAttachmentUploadActions dAction)
{
Id = item.Id;
CommunityId = idCommunity;
IdEvent = (item.EventOwner != null ? item.EventOwner.Id : 0);
EventItem = item;
Permission = module;
LessonNumber = lessonNumber;
if (String.IsNullOrWhiteSpace(description))
{
description = "";
}
Description = description;
UploadActions = actions;
DefaultUploadAction = dAction;
Attachments = new List <dtoAttachmentItem>();
}
public void EditItemVisibility(long idItem, Int32 idCommunity, String unknownUser)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity);
}
else
{
ModuleCommunityDiary module = Service.GetPermissions(UserContext.CurrentUserID, idCommunity);
CommunityEventItem item = Service.EventItemGet(idItem);
if (item != null && module.Edit)
{
Service.EditEventItemVisibility(item);
}
LoadDiaryItems(idCommunity, unknownUser);
}
}
private StatTreeNode <StatFileTreeLeaf> CreateTaskTreeNode(CommunityEventItem item, int lessonNumber, Dictionary <int, string> translations)
{
StatTreeNode <StatFileTreeLeaf> node = new StatTreeNode <StatFileTreeLeaf>()
{
Id = 0, isVisible = true, NodeObjectTypeId = (int)ModuleTasklist.ObjectType.Task
};
node.Name = (item.ShowDateInfo) ?
string.Format(translations[(int)TreeItemsTranslations.StandardDiaryItemName], (lessonNumber < 1) ? "" : lessonNumber.ToString())
:
string.Format(translations[(int)TreeItemsTranslations.NoDateDiaryItemName], (lessonNumber < 1) ? "" : lessonNumber.ToString());
node.ToolTip = (item.ShowDateInfo) ?
string.Format(translations[(int)TreeItemsTranslations.StandardDiaryItemNameToolTip], (lessonNumber < 1) ? "" : lessonNumber.ToString(), item.StartDate.ToString("dd/MM/YY"), item.StartDate.ToString("hh:mm"), item.EndDate.ToString("hh:mm"))
:
string.Format(translations[(int)TreeItemsTranslations.NoDateDiaryItemNameToolTip], (lessonNumber < 1) ? "" : lessonNumber.ToString());
return(node);
}
public void EditFileItemVisibility(long idItem, long idAttachment, Int32 idCommunity, Boolean visibleForModule, Boolean visibleForRepository, String unknownUser)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
ModuleCommunityDiary module = Service.GetPermissions(UserContext.CurrentUserID, idCommunity);
CommunityEventItem item = Service.EventItemGet(idItem);
EventItemFile attachment = Service.EventItemGetAttachment(idAttachment);
if (item != null && attachment != null)
{
Service.AttachmentEditVisibility(item, attachment, visibleForModule, visibleForRepository);
}
LoadDiaryItems(idCommunity, unknownUser);
}
}
private Boolean AllowDownloadFileLinkedToItem(long idAttachment, Int32 idUser)
{
Boolean iResponse = false;
EventItemFile attachment = Manager.Get <EventItemFile>(idAttachment);
litePerson person = Manager.GetLitePerson(idUser);
if (attachment != null && attachment.Item != null && attachment.Link != null)
{
CommunityEventItem item = EventItemGet(attachment.IdItemOwner);
if (item != null)
{
ModuleCommunityDiary modulePermission = GetPermissions(idUser, attachment.IdCommunity);
lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository = GetCoreModuleRepository(idUser, attachment.IdCommunity);
CoreItemPermission itemPermission = GetItemPermission(person, EventItemGet(attachment.IdItemOwner), modulePermission, moduleRepository);
iResponse = AllowViewFileFromLink(modulePermission, itemPermission, attachment, person) && (attachment.Item.IsDownloadable || (attachment.Item.IdOwner == idUser && attachment.Item.Availability != Core.FileRepository.Domain.ItemAvailability.notavailable));
}
}
return(iResponse);
}
public CoreItemPermission GetItemPermissionFromLink(long idLink)
{
CoreItemPermission permission = new CoreItemPermission();
liteModuleLink link = Manager.Get <liteModuleLink>(idLink);
if (link != null)
{
EventItemFile itemFileLink = (from f in Manager.GetIQ <EventItemFile>() where f.Link != null && f.Link.Id == idLink && f.Deleted == BaseStatusDeleted.None select f).Skip(0).Take(1).ToList().FirstOrDefault();
if (itemFileLink != null)
{
CommunityEventItem item = EventItemGet(itemFileLink.IdItemOwner);
if (item != null)
{
permission = GetItemPermission(item, ServicePermission(UC.CurrentUserID, itemFileLink.IdCommunity), GetCoreModuleRepository(UC.CurrentUserID, itemFileLink.IdCommunity));
}
}
}
return(permission);
}
public void SaveItem(Int32 idCommunity, long idItem, CommunityEventItem dto, String description, String descriptionPlain)
{
if (UserContext.isAnonymous)
{
View.DisplaySessionTimeout(idCommunity, idItem);
}
else
{
CommunityEventItem item = SaveDiaryItem(idCommunity, idItem, dto, description, descriptionPlain);
if (item == null)
{
View.SetBackToDiary(idCommunity, idItem);
}
else
{
View.CurrentIdItem = item.Id;
View.SendToItemsList(idCommunity, item.Id);
}
}
}
public CoreItemPermission GetItemPermission(litePerson person, CommunityEventItem item, ModuleCommunityDiary modulePermissions, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository)
{
CoreItemPermission iResponse = new CoreItemPermission();
if (item != null)
{
Boolean AllowInternalEdit = item.AllowEdit;
iResponse.AllowViewFiles = (modulePermissions.ViewDiaryItems && (item.IsVisible || (item.IsVisible == false && item.Owner != null && item.Owner == person))) || modulePermissions.Administration;
iResponse.AllowAddFiles = AllowInternalEdit && ((item.Owner != null && item.Owner == person) || modulePermissions.Administration || modulePermissions.UploadFile);
iResponse.AllowDelete = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
iResponse.AllowEdit = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
iResponse.AllowUnDelete = AllowInternalEdit && ((modulePermissions.DeleteItem && item.Owner != null && item.Owner == person) || modulePermissions.Administration);
}
iResponse.AllowView = modulePermissions.Administration || modulePermissions.ViewDiaryItems;
iResponse.AllowVirtualDelete = iResponse.AllowDelete;
iResponse.AllowViewStatistics = iResponse.AllowViewFiles;
iResponse.AllowFilePublish = (moduleRepository != null && (moduleRepository.Administration || moduleRepository.UploadFile));
return(iResponse);
}
public void EditEventItemVisibility(CommunityEventItem item)
{
litePerson person = Manager.GetLitePerson(UC.CurrentUserID);
if (person != null && item != null)
{
try
{
Manager.BeginTransaction();
item.IsVisible = !item.IsVisible;
item.ModifiedBy = person;
item.ModifiedOn = DateTime.Now;
Manager.SaveOrUpdate(item);
Manager.Commit();
}
catch (Exception ex)
{
Manager.RollBack();
}
}
}
public List <dtoAttachmentItem> AttachmentsGet(litePerson person, CommunityEventItem item, Boolean viewAlsoDeleted, CoreItemPermission permissions, lm.Comol.Core.FileRepository.Domain.ModuleRepository moduleRepository, String unknownUser)
{
List <dtoAttachmentItem> items = null;
try
{
if (item != null)
{
items = new List <dtoAttachmentItem>();
List <dtoAttachment> attachments = AttachmentsGet(person, item, viewAlsoDeleted, unknownUser);
items = attachments.Where(a => a.IdModuleLink > 0).OrderBy(a => a.DisplayOrder).ThenBy(a => a.DisplayName).Select(a => new dtoAttachmentItem()
{
Attachment = a, Permissions = AttachmentGetPermissions(person, a, permissions, moduleRepository)
}).ToList();
}
}
catch (Exception ex)
{
items = null;
}
return(items);
}
