public virtual async Task <LinkPreviewModel> Preview(string url)
{
var openGraphObject = _openGraphService.GetOpenGraphObject(url);
if (openGraphObject != null)
{
var localRequestEntity = Map(openGraphObject);
_previewRepository.Add(localRequestEntity);
return(_linkPreviewModelMapper.MapPreview(localRequestEntity));
}
var result = await _linkPreviewClient.GetLinkPreview(url);
if (!result.IsSuccess)
{
return(null);
}
var entity = Map(result.Preview, url);
_previewRepository.Add(entity);
var linkPreview = _linkPreviewModelMapper.MapPreview(entity);
return(linkPreview);
}
public void Add(Guid groupId, GroupMemberSubscriptionModel model)
{
var groupMember = GetNewGroupMember(groupId, model);
_groupMemberRepository.Add(groupMember);
_memberCacheService.UpdateMemberCache(groupMember.MemberId);
}
public void Create(IntranetActivityEntity entity)
{
entity.Id = Guid.NewGuid();
entity.ModifyDate = DateTime.UtcNow;
entity.CreatedDate = DateTime.UtcNow;
_sqlRepository.Add(entity);
}
public void Notify(NotifierData data)
{
var identity = GetSettingsIdentity(data);
var settings = _notificationSettingsService.Get <EmailNotifierTemplate>(identity);
if (!settings.IsEnabled)
{
return;
}
var receivers = _intranetUserService.GetMany(data.ReceiverIds).ToList();
foreach (var receiverId in data.ReceiverIds)
{
var user = receivers.Find(receiver => receiver.Id == receiverId);
var message = _notificationModelMapper.Map(data.Value, settings.Template, user);
_mailService.Send(message);
_notificationRepository.Add(new global::Uintra.Notification.Notification()
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow,
IsNotified = true,
IsViewed = false,
Type = data.NotificationType.ToInt(),
NotifierType = NotifierTypeEnum.EmailNotifier.ToInt(),
Value = new { message }.ToJson(),
ReceiverId = receiverId
});
}
}
public void AddLinkPreview(Guid commentId, int previewId)
{
var entity = new CommentToLinkPreviewEntity {
CommentId = commentId, LinkPreviewId = previewId
};
_previewRelationRepository.Add(entity);
}
public void AddLinkPreview(Guid activityId, int previewId)
{
var entity = new ActivityToLinkPreviewEntity {
ActivityId = activityId, LinkPreviewId = previewId
};
_previewRelationRepository.Add(entity);
}
public override void AddMany(Guid groupId, IEnumerable <Guid> memberIds)
{
var enumeratedMemberIds = memberIds as Guid[] ?? memberIds.ToArray();
var groupMembers = enumeratedMemberIds
.Select(memberId => GetNewGroupMember(groupId, memberId))
.ToList();
_groupMemberRepository.Add(groupMembers);
_memberCacheService.UpdateMemberCache(enumeratedMemberIds);
}
public void Create(string name, Version version)
{
var migrationHistory = new MigrationHistory
{
Name = name,
Version = version.ToString(),
CreateDate = DateTime.Now
};
_migrationHistoryRepository.Add(migrationHistory);
}
public void AddRelation(Guid groupId, Guid activityId)
{
var relation = new GroupActivityRelation
{
ActivityId = activityId,
GroupId = groupId,
Id = Guid.NewGuid()
};
_groupActivityRepository.Add(relation);
}
public void Log(bool result, string message, int mediaId)
{
_sqlLogRepository.Add(new VideoConvertationLog
{
Id = Guid.NewGuid(),
Message = message.ToJson(),
MediaId = mediaId,
Result = result,
Date = DateTime.UtcNow
});
}
public virtual CommentModel Create(CommentCreateDto dto)
{
var entity = Map(dto);
entity.CreatedDate = entity.ModifyDate = DateTime.UtcNow;
_commentsRepository.Add(entity);
if (dto.LinkPreviewId.HasValue)
{
_commentLinkPreviewService.AddLinkPreview(entity.Id, dto.LinkPreviewId.Value);
}
return entity.Map<CommentModel>();
}
public void Create(Guid entityId, string mediaIds)
{
if (!string.IsNullOrEmpty(mediaIds) && !string.IsNullOrWhiteSpace(mediaIds))
{
_sqlRepository.Add(new IntranetMediaEntity
{
Id = Guid.NewGuid(),
EntityId = entityId,
MediaIds = mediaIds
});
}
}
public virtual ActivitySubscribeSetting Create(ActivitySubscribeSettingDto setting)
{
var createSetting = new ActivitySubscribeSetting
{
ActivityId = setting.ActivityId,
CanSubscribe = setting.CanSubscribe,
SubscribeNotes = setting.SubscribeNotes
};
_activitySubscribeSettingRepository.Add(createSetting);
return(createSetting);
}
public override void AddMany(Guid groupId, IEnumerable <Guid> memberIds)
{
var groupMembers = new List <GroupMember>();
var enumeratedMemberIds = memberIds as Guid[] ?? memberIds.ToArray();
foreach (var memberId in enumeratedMemberIds)
{
groupMembers.Add(GetNewGroupMember(groupId, memberId));
}
_groupMemberRepository.Add(groupMembers);
_userCacheService.UpdateUserCache(enumeratedMemberIds);
}
public Guid Create(GroupModel model)
{
var date = DateTime.UtcNow;
var group = model.Map <Group>();
group.CreatedDate = date;
group.UpdatedDate = date;
group.Id = Guid.NewGuid();
_groupRepository.Add(group);
UpdateCache();
return(group.Id);
}
public virtual Subscribe Subscribe(Guid userId, Guid activityId)
{
var entity = new Subscribe
{
Id = Guid.NewGuid(),
ActivityId = activityId,
UserId = userId,
CreatedDate = DateTime.UtcNow,
IsNotificationDisabled = true
};
_subscribeRepository.Add(entity);
return(entity);
}
public Guid Create(MyLinkDTO model)
{
var entity = new MyLink
{
Id = Guid.NewGuid(),
UserId = model.UserId,
ContentId = model.ContentId,
QueryString = model.QueryString.Trim('?'),
CreatedDate = DateTime.UtcNow,
ActivityId = model.ActivityId
};
_myLinksRepository.Add(entity);
return(entity.Id);
}
public virtual void Add(Guid userId, Guid entityId)
{
if (CanAdd(userId, entityId))
{
var like = new Like
{
Id = Guid.NewGuid(),
EntityId = entityId,
UserId = userId,
CreatedDate = DateTime.UtcNow
};
_likesRepository.Add(like);
}
}
public void Notify(IEnumerable <UiNotificationMessage> messages)
{
var notifications = messages
.Select(el => new Notification
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow,
IsNotified = false,
IsViewed = false,
Type = el.NotificationType.ToInt(),
Value = new { el.Message, el.Url, el.NotifierId, el.IsPinned, el.IsPinActual }.ToJson(),
ReceiverId = el.ReceiverId
});
_notificationRepository.Add(notifications);
}
public void CreateIfNotExists(Guid activityId, ReminderTypeEnum type)
{
if (_reminderRepository.Exists(r => r.ActivityId == activityId && r.Type == type))
{
return;
}
var entity = new Notification.Sql.Reminder
{
Id = Guid.NewGuid(),
ActivityId = activityId,
Type = type
};
_reminderRepository.Add(entity);
}
public virtual async Task <LinkPreview.LinkPreview> Preview(string url)
{
var result = await _linkPreviewClient.GetLinkPreview(url);
if (!result.IsSuccess)
{
return(null);
}
var entity = Map(result.Preview, url);
_previewRepository.Add(entity);
var model = _linkPreviewModelMapper.MapPreview(entity);
return(model);
}
public void Notify(IEnumerable <PopupNotificationMessage> messages)
{
var notifications = messages
.Select(el => new Sql.Notification
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow,
IsNotified = true,
IsViewed = false,
Type = el.NotificationType.ToInt(),
NotifierType = NotifierTypeEnum.PopupNotifier.ToInt(),
Value = new { el.Message }.ToJson(),
ReceiverId = el.ReceiverId
});
_notificationRepository.Add(notifications);
}
public Reminder CreateIfNotExists(Guid activityId, ReminderTypeEnum type)
{
if (_remindeRepository.Exists(r => r.ActivityId == activityId && r.Type == type && !r.IsDelivered))
{
return(null);
}
var entity = new Reminder
{
Id = Guid.NewGuid(),
ActivityId = activityId,
Type = type
};
_remindeRepository.Add(entity);
return(entity);
}
public virtual void Save <T>(NotifierSettingModel <T> settingModel) where T : INotifierTemplate
{
var identity = new ActivityEventIdentity(settingModel.ActivityType, settingModel.NotificationType)
.AddNotifierIdentity(settingModel.NotifierType);
var(setting, isCreated) = FindOrCreateSetting <T>(identity);
var updatedSetting = GetUpdatedSetting(setting, settingModel);
if (isCreated)
{
_repository.Add(updatedSetting);
}
else
{
_repository.Update(updatedSetting);
}
}
private IEnumerable <MemberNotifierSetting> CreateAbsentSettings(
Guid memberId,
IEnumerable <Enum> existingSettings,
IEnumerable <Enum> allSettings)
{
var absentSettings = allSettings.Except(existingSettings).ToList();
var newEntities = absentSettings
.Select(s => new MemberNotifierSetting()
{
Id = Guid.NewGuid(),
MemberId = memberId,
NotifierType = s.ToInt(),
IsEnabled = s.ToInt() != NotifierTypeEnum.EmailNotifier.ToInt()
})
.ToList();
_memberNotifierSettingRepository.Add(newEntities);
return(newEntities);
}
public void Notify(IEnumerable <UiNotificationMessage> messages)
{
var notifications = messages
.Select(el => new Sql.Notification
{
Id = Guid.NewGuid(),
Date = DateTime.UtcNow,
IsNotified = false,
NotifierType = NotifierTypeEnum.UiNotifier.ToInt(),
IsViewed = false,
Type = el.NotificationType.ToInt(),
Value = new { el.Message, el.Url, el.NotifierId, el.NotifierPhotoUrl, el.IsPinned, el.IsPinActual, el.DesktopMessage, el.DesktopTitle, el.IsDesktopNotificationEnabled }.ToJson(),
ReceiverId = el.ReceiverId
}).ToList();
_notificationRepository.Add(notifications);
var notNotifiedNotifications = notifications.SelectMany(i => GetNotNotifiedNotifications(i.ReceiverId));
SendNewUiNotificationsArrived(notNotifiedNotifications);
}
public Result <Document> Insert(Document document)
{
Result <Document> result = new Result <Document>();
try
{
result.ResultEntity = _repository.Add(document);
result.ResultMessage = "Saved";
result.ResultStatus = true;
result.ResultCode = ResultCodes.OK.GetHashCode();
}
catch (Exception ex)
{
result.ResultEntity = null;
result.ResultStatus = false;
result.ResultMessage = "Error";
result.ResultInnerMessage = ex.ToString();
result.ResultCode = ResultCodes.Error.GetHashCode();
}
return(result);
}
public void Set(Guid activityId, ActivityLocation location)
{
var oldLocation = _locationRepository
.AsQueryable()
.SingleOrDefault(l => l.ActivityId == activityId);
if (oldLocation is null)
{
if (location is null)
{
return;
}
var newLocation = new ActivityLocationEntity()
{
ActivityId = activityId,
Address = location.Address,
ShortAddress = location.ShortAddress
};
_locationRepository.Add(newLocation);
}
else
{
if (location?.Address == null || location.ShortAddress == null)
{
_locationRepository.Delete(oldLocation);
}
else
{
oldLocation.Address = location.Address;
oldLocation.ShortAddress = location.ShortAddress;
_locationRepository.Update(oldLocation);
}
}
}
public virtual void Add(Guid entityId, IEnumerable <Guid> tagIds)
{
var entities = tagIds.Select(tagId => MapToEntity(entityId, tagId));
_relationRepository.Add(entities);
}
public Guid Create(GroupDocument document)
{
document.Id = Guid.NewGuid();
_repository.Add(document);
return(document.Id);
}
