public IEnumerable <priz> GetAll()
{
using (var dbContext = _dbContextFactory.Create())
{
return(dbContext.Set <priz>().ToList());
}
}
public void AddOrganizationRole(string name)
{
using (LabDbEntities entities = _dbContextFactory.Create())
{
OrganizationRole newRole = new OrganizationRole
{
Name = name,
Description = ""
};
entities.OrganizationRoles.Add(newRole);
foreach (Organization org in entities.Organizations)
{
OrganizationRoleMapping newMapping = new OrganizationRoleMapping
{
Role = newRole,
Organization = org,
IsSelected = false
};
entities.OrganizationRoleMappings.Add(newMapping);
}
entities.SaveChanges();
}
}
public async Task <List <Contact> > GetContacts(IEnumerable <Guid> contactIds, CancellationToken cancellationToken)
{
await using var db = _dbContextFactory.Create();
return(await db.Contacts.Where(c => contactIds.Contains(c.Id))
.ToListAsync(cancellationToken));
}
public void SaveEvent <TAggregate>(IDomainEvent @event) where TAggregate : IAggregateRoot
{
using (var context = _contextFactory.Create())
{
var aggregate = context.DomainAggregates.FirstOrDefault(x => x.Id == @event.AggregateRootId);
if (aggregate == null)
{
context.DomainAggregates.Add(new DomainAggregate
{
Id = @event.AggregateRootId,
Type = typeof(TAggregate).AssemblyQualifiedName
});
}
var currentSequenceCount = context.DomainEvents.Count(x => x.DomainAggregateId == @event.AggregateRootId);
context.DomainEvents.Add(new DomainEvent
{
DomainAggregateId = @event.AggregateRootId,
SequenceNumber = currentSequenceCount + 1,
Type = @event.GetType().AssemblyQualifiedName,
Body = JsonConvert.SerializeObject(@event),
TimeStamp = @event.TimeStamp
//UserId = @event.UserId
});
context.SaveChanges();
}
}
public void Transaction(Action <TDbContext> transaction)
{
using (var context = dbContextFactory.Create())
{
transaction(context);
}
}
public async Task <bool> IsUserInConversationAsync(ConversationType conversationType, long conversationId, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
switch (conversationType)
{
case ConversationType.Dialog:
{
return(await context.Dialogs
.AnyAsync(opt => (opt.FirstUID == userId) && opt.Id == conversationId).ConfigureAwait(false));
}
case ConversationType.Chat:
{
return(await context.ChatUsers
.AnyAsync(opt => opt.UserId == userId && opt.ChatId == conversationId && !opt.Deleted && !opt.Banned).ConfigureAwait(false));
}
case ConversationType.Channel:
{
return(await context.ChannelUsers
.AnyAsync(opt => opt.UserId == userId && opt.ChannelId == conversationId && !opt.Deleted && !opt.Banned).ConfigureAwait(false));
}
default:
return(false);
}
}
}
public MenuViewModel GetByName(Guid siteId, string name, Guid languageId = new Guid())
{
return(_cacheManager.Get(string.Format(CacheKeys.MenuCacheKey, siteId, name, languageId), () =>
{
using (var context = _dbContextFactory.Create())
{
var menu = context.Menus.FirstOrDefault(x => x.SiteId == siteId && x.Name == name && x.Status != MenuStatus.Deleted);
if (menu == null)
{
return new MenuViewModel();
}
LoadMenuItems(context, menu);
var language = languageId != Guid.Empty
? context.Languages.FirstOrDefault(x => x.SiteId == siteId && x.Id == languageId && x.Status == LanguageStatus.Active)
: null;
bool addLanguageSlug = context.Sites.Where(x => x.Id == siteId).Select(site => site.AddLanguageSlug).FirstOrDefault();
var menuModel = new MenuViewModel
{
Name = menu.Name,
MenuItems = PopulateMenuItems(context, menu.MenuItems, Guid.Empty, language, addLanguageSlug)
};
return menuModel;
}
}));
}
public async Task <PollDto> GetPollAsync(Guid pollId, long conversationId, ConversationType conversationType)
{
using (MessengerDbContext context = contextFactory.Create())
{
var poll = await context.Polls
.Include(opt => opt.Options)
.ThenInclude(opt => opt.PollOptionVotes)
.FirstOrDefaultAsync(opt =>
opt.PollId == pollId &&
opt.ConvertsationId == conversationId &&
opt.ConversationType == conversationType)
.ConfigureAwait(false);
if (poll == null)
{
var nodeId = await conversationsService.GetConversationNodeIdAsync(conversationType, conversationId).ConfigureAwait(false);
var connection = connectionsService.GetNodeConnection(nodeId);
if (connection != null)
{
var loadedPoll = await nodeRequestSender.GetPollInformationAsync(conversationId, conversationType, pollId, connection).ConfigureAwait(false);
loadedPoll = await SavePollAsync(loadedPoll).ConfigureAwait(false);
return(loadedPoll);
}
}
return(PollConverter.GetPollDto(poll));
}
}
public IEnumerable <IngredientListModel> GetAll()
{
using var dbContext = _dbContextFactory.Create();
return(dbContext.Ingredients
.Select(e => IngredientMapper.MapIngredientEntityToListModel(e)).ToArray());
}
public void Add(ILabel addObj)
{
using (WisTEntities context = _contextFactory.Create())
{
User user = new User(addObj);
context.Users.Add(user);
foreach (var image in addObj.Images)
{
user.UserImages.Add(new UserImage(image));
}
try
{
context.SaveChanges();
}
catch
{
throw new AddExistingUserException();
}
addObj.Id = new Identifier(user.Id);
}
}
public async Task <ApiResult> Insert(InsertAutomation request, CancellationToken cancellationToken)
{
var item = request.Item ?? throw new ArgumentNullException(nameof(request.Item));
item.Uid = Guid.NewGuid();
var dbConditions = CollectDbConditions(item);
var dbActions = CollectDbActions(item);
int affected;
using (var db = _dbContextFactory.Create())
{
affected = await db.GetTable <DbAutomation>()
.Value(x => x.Uid, item.Uid)
.Value(x => x.EntityTypeCode, request.EntityTypeCode)
.Value(x => x.EntityTypeUid, request.EntityTypeUid)
.Value(x => x.TypeCode, "trigger") // todo: ask user
.Value(x => x.Name, item.Name)
.Value(x => x.Description, item.Description)
.Value(x => x.IsActive, true)
.Value(x => x.IsSystem, item.System)
.Value(x => x.DisplayOrder, item.DisplayOrder)
.InsertAsync(cancellationToken);
await db.GetTable <DbAutomationAction>().BulkCopyAsync(dbActions, cancellationToken);
await db.GetTable <DbAutomationCondition>().BulkCopyAsync(dbConditions, cancellationToken);
}
return(new ApiResult {
Uid = item.Uid, AffectedRows = affected
});
}
public async Task DeleteUserInformationAsync(long userId)
{
try
{
using (MessengerDbContext context = contextFactory.Create())
{
User user = await context.Users
.Include(opt => opt.Emails)
.Include(opt => opt.Phones)
.Include(opt => opt.Tokens)
.FirstOrDefaultAsync(opt => opt.Id == userId)
.ConfigureAwait(false);
user.Phones = null;
user.Emails = null;
user.About = null;
user.Birthday = null;
user.City = null;
user.Country = null;
user.Sha512Password = null;
user.Photo = null;
user.NameSecond = null;
user.NameFirst = "unknown";
user.Tokens = null;
context.Update(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <string> AddNewOperationAsync(long nodeId, long userId)
{
using (MessengerDbContext context = contextFactory.Create())
{
long currentTime = DateTime.UtcNow.ToUnixTime();
var uncomplededOperation = await context.ChangeUserNodeOperations
.FirstOrDefaultAsync(opt => !opt.Completed && opt.UserId == userId && opt.ExpirationTime > currentTime).ConfigureAwait(false);
if (uncomplededOperation != null)
{
context.Remove(uncomplededOperation);
}
ChangeUserNodeOperation operation = new ChangeUserNodeOperation
{
NodeId = nodeId,
UserId = userId,
OperationId = RandomExtensions.NextString(64),
Completed = false,
RequestTime = currentTime,
ExpirationTime = currentTime + (long)TimeSpan.FromDays(1).TotalSeconds
};
await context.AddAsync(operation).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(operation.OperationId);
}
}
public virtual TDocument Get(Guid documentId)
{
using (var ctx = dbContextFactory.Create())
{
return(ctx.Set <TDocument>().FirstOrDefault(x => x.GUID == documentId));
}
}
public void Add(Review review)
{
var dbContext = _dbContextFactory.Create();
dbContext.Reviews.Add(review);
dbContext.SaveChanges();
}
public async Task <ChannelVm> EditChannelAsync(ChannelVm channel, long editorUserId)
{
using (MessengerDbContext context = contextFactory.Create())
{
ChannelUser channelUser = await context.ChannelUsers
.Include(opt => opt.Channel)
.FirstOrDefaultAsync(opt =>
opt.ChannelId == channel.ChannelId &&
opt.UserId == editorUserId &&
opt.ChannelUserRole >= ChannelUserRole.Administrator)
.ConfigureAwait(false);
if (channelUser != null)
{
if (channelUser.ChannelUserRole == ChannelUserRole.Administrator && (channelUser.Banned || channelUser.Deleted))
{
throw new PermissionDeniedException();
}
channelUser.Channel = ChannelConverter.GetChannel(channelUser.Channel, channel);
context.Update(channelUser.Channel);
await context.SaveChangesAsync().ConfigureAwait(false);
var editedChannel = ChannelConverter.GetChannel(channelUser.Channel);
editedChannel.UserRole = channelUser.ChannelUserRole;
editedChannel.SubscribersCount = await context.ChannelUsers.CountAsync(opt => opt.Deleted == false && opt.ChannelId == channel.ChannelId).ConfigureAwait(false);
return(editedChannel);
}
throw new PermissionDeniedException();
}
}
public async Task <QRCodeContent> CreateQRCodeAsync(long userId, long nodeId)
{
var sequence = RandomExtensions.NextBytes(192);
string sequenceStr = Convert.ToBase64String(sequence);
QRCode qrCode = new QRCode
{
UserId = userId,
SequenceHash = GetSequenceHashSha512(sequenceStr)
};
using (MessengerDbContext context = contextFactory.Create())
{
bool isUserExists = await context.Users.AnyAsync(user => user.Id == userId).ConfigureAwait(false);
if (!isUserExists)
{
throw new ObjectDoesNotExistsException($"User with Id: {userId} does not found.");
}
await context.QRCodes.AddAsync(qrCode).ConfigureAwait(false);
await context.SaveChangesAsync().ConfigureAwait(false);
return(new QRCodeContent(qrCode.Id, qrCode.UserId, nodeId, sequenceStr));
}
}
public APIResult GetList([FromBody] GetListArgsModel args)
{
using (var db = dbFactory.Create(_communityService, args.CommunityFlag, args.AppFlag))
{
var query = db.Query <SettingBase>()
.Where(m => !m.IsDel);
var list = query
.OrderByDescending(m => m.Id)
.Select(m => new RowItem()
{
Detail = m.Detail,
Flag = m.Flag,
GroupFlag = m.GroupFlag,
Id = m.Id,
IsDel = m.IsDel,
SettingType = m.SettingType,
Value = m.Value
})
.ToList();
return(Success(new GetListModel()
{
Items = list
}));
}
}
public ValidationReportDetails GetValidationReportDetails(int validationReportId)
{
LoggingService.LogDebugMessage($"Retrieving Validation Report Details for report with ID number: {validationReportId.ToString()}");
using (var portalDbContext = DbContextFactory.Create())
{
var reportDetails = portalDbContext.ValidationReportDetails
.Include(x => x.ValidationReportSummary)
.Include(x => x.ValidationReportSummary.SchoolYear)
.FirstOrDefault(x => x.ValidationReportSummaryId == validationReportId);
if (reportDetails != null)
{
reportDetails.CompletedWhen =
reportDetails.CompletedWhen?.ToLocalTime() ?? reportDetails.CompletedWhen;
reportDetails.ValidationReportSummary.RequestedWhen =
reportDetails.ValidationReportSummary.RequestedWhen.ToLocalTime();
LoggingService.LogDebugMessage(
$"Successfully retrieved Validation Report Details for report with ID number: {validationReportId.ToString()}");
}
return(reportDetails);
}
}
public User GetById(Guid id)
{
using (var context = _dbContextFactory.Create())
{
var dbEntity = context.Users.FirstOrDefault(x => x.Id == id && x.Status != UserStatus.Deleted);
return(dbEntity != null?_mapper.Map <User>(dbEntity) : null);
}
}
public async Task Create(Document document, CancellationToken cancellationToken)
{
document.Uid ??= Guid.NewGuid();
document.StatusCode ??= DocumentStatusCode.Draft;
using (var db = _dbContextFactory.Create())
{
await db.GetTable <DbDocument>()
.Value(x => x.Uid, document.Uid)
.Value(x => x.CompanyUid, document.CompanyUid)
.Value(x => x.DocumentTypeUid, document.DocumentTypeUid)
.Value(x => x.StatusCode, document.StatusCode)
.Value(x => x.Direction, document.Direction.ToString())
.Value(x => x.DocumentNumber, document.DocumentNumber)
.Value(x => x.DocumentDate, document.DocumentDate)
.Value(x => x.Name, document.Name)
.InsertAsync(cancellationToken);
}
/*if (document.StatusCode != DocumentStatusCode.Draft)
* {
* await _mediator.Publish(new EntityStatusChanged<Document>
* {
* Entity = document,
* StatusCode = DocumentStatusCode.Draft
* }, cancellationToken);
* }*/
if (document.StatusCode == DocumentStatusCode.Published)
{
var documentNumber = await _numberGenerator
.GenerateNumber(new GenerateNumberRequest
{
EntityTypeCode = DocumentType.EntityTypeCode,
EntityTypeUid = document.DocumentTypeUid,
EntityUid = document.Uid
}, cancellationToken);
if (documentNumber != null)
{
document.DocumentNumber = documentNumber;
using (var db = _dbContextFactory.Create())
{
await db.GetTable <DbDocument>()
.Where(x => x.Uid == document.Uid)
.Set(x => x.DocumentNumber, documentNumber)
.UpdateAsync(cancellationToken);
}
}
}
await _mediator.Publish(new EntityStatusChanged <Document>
{
Entity = document,
StatusCode = document.StatusCode
}, cancellationToken);
}
public async Task <List <MessageVm> > LoadForwardedMessagesAsync(ForwardedMessagesInfo forwarded, long?requestorId)
{
var messagesCondition = PredicateBuilder.New <Message>();
List <Message> messages = new List <Message>();
switch (forwarded.ConversationType)
{
case ConversationType.Chat:
{
messagesCondition = forwarded.MessagesGlobalId.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value && opt.ChatId == forwarded.ConversationId).Expand());
break;
}
case ConversationType.Dialog:
{
messagesCondition = forwarded.MessagesGlobalId.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value && opt.DialogId == forwarded.ConversationId).Expand());
break;
}
case ConversationType.Channel:
{
messagesCondition = forwarded.MessagesGlobalId.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value && opt.ChannelId == forwarded.ConversationId).Expand());
}
break;
case ConversationType.Unknown:
{
messagesCondition = forwarded.MessagesGlobalId.Aggregate(messagesCondition,
(current, value) => current.Or(opt => opt.GlobalId == value && opt.ChannelId == null && opt.DialogId == null && opt.ChatId == null).Expand());
}
break;
default:
return(null);
}
using (MessengerDbContext context = contextFactory.Create())
{
messages = await context.Messages
.AsNoTracking()
.Include(opt => opt.Attachments)
.Where(messagesCondition)
.ToListAsync().ConfigureAwait(false);
foreach (var message in messages)
{
if (message.ChannelId != null)
{
message.SenderId = null;
}
message.Attachments = message.Attachments.Where(opt => opt.Type != (short)AttachmentType.ForwardedMessages).ToList();
}
return(MessageConverter.GetMessagesVm(MessageConverter.GetMessagesDto(messages), requestorId));
}
}
public async Task <long> CountAsync(StreamId streamId, CancellationToken cancellationToken = default)
{
using (var context = _dbContextFactory.Create())
{
var count = await context.Events.LongCountAsync(@event => @event.StreamId == streamId, cancellationToken);
return(count);
}
}
public IEnumerable <Log> GetIdentityIssues()
{
using (var dbContext = DbContextFactory.Create())
{
return(dbContext.Logs
.ToList()
.Where(x => new Uri(x.Url).PathAndQuery.StartsWith($"/{ApiName}/api/identity/")));
}
}
/// <summary>
/// Gets the context from the ambient <see cref="IEfUnitOfWork"/> if one exists,
/// else it tries to create a new one via service location with the specified registered name.
/// </summary>
/// <param name="registeredNameForServiceLocation">The context's registered name for service location.</param>
/// <returns>Instance of <see cref="DbContext"/>.</returns>
/// <remarks></remarks>
public DbContext GetOrCreateDbContext(String registeredNameForServiceLocation)
{
if (!AmbientEfUnitOfWorkExists())
{
return(_DbContextFactory.Create(registeredNameForServiceLocation));
}
return(GetOrCreateDbContextForUnitOfWork(registeredNameForServiceLocation));
}
public async Task <int> Create(Gateway gateway)
{
using (var _context = _factory.Create()) {
var r1 = _context.Gateways.Add(gateway);
var result = await _context.SaveChangesAsync();
return(r1.id);
}
}
public async Task AddAsync(Contact contact)
{
await using (var context = _dbContextFactory.Create())
{
await context.AddAsync(contact);
await SaveDbContextChangesAsync(context);
}
}
public IReadOnlyUnitOfWork StartReadOnlyUnit(Guid userId)
{
if (userId == Guid.Empty)
{
throw new ArgumentOutOfRangeException(nameof(userId), $"{nameof(userId)} cannot be empty.");
}
return(new ReadOnlyUnitOfWorkWithPermissions(_factory.Create(), userId));
}
/// <summary>
/// Fetches/selects all job definitions. Since we know there will not be many jobs we will not apply
/// filtering or pagination.
/// </summary>
/// <param name="ordering">OrderBy clause</param>
/// <returns>List of job definitions</returns>
public IList <JobDefinition> FetchJobDefinitions(string ordering)
{
using (IDbContext dbContext = _dbContextFactory.Create())
{
return(dbContext.Set <JobDefinition>()
.OrderBy(ordering)
.ToList());
}
}
public ModuleType GetById(Guid id)
{
using (var context = _dbContextFactory.Create())
{
var dbEntity = context.ModuleTypes
.FirstOrDefault(x => x.Id == id && x.Status != ModuleTypeStatus.Deleted);
return(dbEntity != null?_mapper.Map <ModuleType>(dbEntity) : null);
}
}
