public async Task <IList <SettingViewModel> > Get()
{
var settings = await _settingService.GetSettings(_tenantProvider.GetTenantId());
var list = _mapper.Map <IList <Setting>, IList <SettingViewModel> >(settings.ToList());
return(list);
}
public IActionResult GetAccounts()
{
var accounts = _db.Accounts.Where(acc => acc.AccountOwnerId == _tenantProvider.GetTenantId()).ToList();
if (accounts != null)
{
return(Ok(accounts.Select(acc => new AccountViewModel(acc))));
}
return(NotFound());
}
/// <summary>
/// 新增实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual TEntity Add(TEntity entity)
{
//验证是否又租户
if (typeof(IMustHaveTenant).IsAssignableFrom(entity.GetType()))
{
var tenantId = _tenantProvider.GetTenantId();
if (tenantId != 0)
{
entity.GetType().GetProperty("TenantId").SetValue(entity, tenantId);
}
}
return(DbContext.Add(entity).Entity);
}
public virtual Task InsertAsync(TEntity entity)
{
_logger?.LogInformation($"Método: { nameof(InsertAsync) }( {{entity:{ entity.ToJson() }}} )");
var entityIsITenant = entity is ITenant <TKey>;
if (entityIsITenant)
{
_logger?.LogInformation($"Executando SetTenantId({_tenantProvider.GetTenantId()}) em InsertAsync");
((ITenant <TKey>)entity).SetTenantId(_tenantProvider.GetTenantId());
}
return(Set.AddAsync(entity).AsTask());
}
public void SetInsertHeader(DynamicWrapper document)
{
var userInfo = GetCurrentUserInfo();
var header = new DynamicWrapper
{
["_tenant"] = _tenantProvider.GetTenantId(),
["_created"] = DateTime.UtcNow,
["_createUser"] = userInfo.Item1,
["_createUserId"] = userInfo.Item2
};
document["_header"] = header;
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <Booking>().HasData(Seed.Bookings);
modelBuilder.Entity <Booking>().HasQueryFilter(p => p.TenantId == _tenantProvider.GetTenantId());
}
public override async Task <int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = new CancellationToken())
{
ChangeTracker.DetectChanges();
foreach (var entity in ChangeTracker.Entries().Where(e => e.State == EntityState.Added))
{
entity.Property("ShadowId").CurrentValue = Guid.NewGuid();
if (IsDomainEntity(entity.Metadata.ClrType.BaseType))
{
entity.Property("TenantId").CurrentValue = _tenantProvider.GetTenantId();
entity.Property("CreatedOn").CurrentValue = DateTime.UtcNow;
}
}
return(await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken));
}
public PlaylistContext(DbContextOptions <PlaylistContext> options,
ITenantProvider tenantProvider,
IEntityTypeProvider entityTypeProvider)
: base(options)
{
_tenantId = tenantProvider.GetTenantId();
_entityTypeProvider = entityTypeProvider;
}
public ApplicationDbContext(
DbContextOptions <ApplicationDbContext> options,
ITenantProvider tenantProvider,
IEntityTypeProvider entityTypeProvider)
: base(options)
{
_teanantId = tenantProvider.GetTenantId();
_entityTypeProvider = entityTypeProvider;
}
public async Task <IActionResult> Save([FromBody] NewPolicyViewModel viewModel)
{
var hasActivePoll = await _policyService.HasActivePoll();
if (hasActivePoll)
{
ModelState.AddModelError("", _localizer["HasActivePoll"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
var latestAuthorityPoll = await _pollService.GetLastPollOfType <AuthorityPoll>();
if (latestAuthorityPoll == null)
{
ModelState.AddModelError("", _localizer["CantStartPollBeforeAuthorityComplete"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
if (latestAuthorityPoll.Result == "Kararsız" ||
latestAuthorityPoll.Result == PollResults.Undecided.ToString())
{
ModelState.AddModelError("", _localizer["CantStartPollBeforeAuthorityComplete"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
if (await _pollService.HasActivePollOfType <AuthorityPoll>())
{
ModelState.AddModelError("", _localizer["AuthorityPollActivePollError"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
var userId = User.ApiGetUserId();
var policy = await _policyService.Add(new Policy
{
UserId = userId,
TenantId = _tenantProvider.GetTenantId(),
Body = viewModel.Body,
Title = viewModel.Title,
CreatedAt = DateTime.UtcNow,
PolicyStatus = PolicyStatus.Voting
});
var poll = await _pollViewModelService.NewPolicyChangePoll(new PolicyChangePollViewModel
{
UserId = userId,
StartedBy = userId,
Name = "Yönetmelik Değişim Oylaması",
Description = viewModel.PollDescription,
PolicyId = policy.Id
});
await _pollService.NotifyUsers(poll.PollType, PollNotificationTypes.Started, poll);
return(Ok(_mapper.Map <PolicyChangePoll, PolicyChangePollViewModel>(poll)));
}
private void Log <TActivityEnum>(
TActivityEnum activityEnum,
string?keyType,
int?keyId,
int?accountId,
object?additionalData,
string message,
params object[] messageData)
{
// call to get tenant, profile id and account id
var tenantId = _tenantProvider.GetTenantId();
var profileId = _profileProvider.GetProfileId();
var properties = new List <ILogEventEnricher>
{
new PropertyEnricher(Constants.SourceContextPropertyName, typeof(TSourceContext)),
new PropertyEnricher("Version", _version),
new PropertyEnricher("ActivityType", activityEnum !.ToString()),
new PropertyEnricher("TenantId", tenantId),
new PropertyEnricher("ProfileId", profileId),
new PropertyEnricher(ActivityLoggerLogConfigurationAdapter.LogTypeKey, _activityLogType)
};
if (keyId != null)
{
properties.Add(new PropertyEnricher("KeyId", keyId));
}
if (keyType != null)
{
properties.Add(new PropertyEnricher("keyType", keyType));
}
if (additionalData != null)
{
properties.Add(new PropertyEnricher("AdditionalProperties", additionalData, true));
}
if (accountId != null)
{
properties.Add(new PropertyEnricher("AccountId", accountId));
}
try
{
using (LogContext.Push(properties.ToArray()))
{
_logger.Information(message, messageData);
}
}
catch (Exception e)
{
_logger.Error("Error activity logging: {message}", e.Message, e);
}
}
}
public ReactAdvantageContext(
DbContextOptions <ReactAdvantageContext> options,
ILogger <ReactAdvantageContext> logger,
ITenantProvider tenantProvider
)
: base(options)
{
Logger = logger;
TenantFilterValue = tenantProvider.GetTenantId();
IsTenantFilterEnabled = true;
}
public async Task <IActionResult> GetUser()
{
var user = await _db.Users.FirstOrDefaultAsync(u => u.Id == _tenantProvider.GetTenantId());
if (user != null)
{
return(Ok(new UserViewModel(user)));
}
return(NotFound());
}
protected override async Task <HttpResponseMessage> SendAsync(
HttpRequestMessage request,
CancellationToken cancellationToken)
{
// TODO: also would be great to add expiration logic
_authToken ??= await _authTokenStore.GetTokenAsync();
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _authToken);
request.Headers.Add("X-Tenant-Id", _tenantProvider.GetTenantId());
return(await base.SendAsync(request, cancellationToken).ConfigureAwait(false));
}
private void ModifyCommand(DbCommand command)
{
if (command.CommandText.StartsWith("UPDATE \"BlogPosts\"") ||
command.CommandText.StartsWith("DELETE FROM \"BlogPosts\""))
{
var parameter = command.CreateParameter();
parameter.ParameterName = "@__TenantId__";
parameter.Value = tenantProvider.GetTenantId();
command.Parameters.Add(parameter);
command.CommandText = command.CommandText.Replace("WHERE",
$"WHERE (\"TenantId\" = {parameter.ParameterName}) AND ");
}
}
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null || !await _userManager.IsEmailConfirmedAsync(user))
{
ModelState.AddModelError("", _localizer["InvalidUser"]);
//// Don't reveal that the user does not exist or is not confirmed
//return RedirectToAction(nameof(ForgotPasswordConfirmation));
return(BadRequest(Errors.GetErrorList(ModelState)));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var linkStart = _config["BaseUrlApi"];
if (!string.IsNullOrEmpty(model.Subdomain))
{
linkStart = $"{model.Subdomain}.{_config["BaseUrlApi"]}";
}
await _emailSender.SendEmailAsync(model.Email, _localizer["ResetPassword"],
$"{_localizer["ToResetPassword"]} : <a href='https://{linkStart}/reset-password?token={WebUtility.UrlEncode(code)}&userId={user.Id}&email={user.Email}&gen=0'>{_localizer["ClickHere"]}</a>",
_tenantProvider.GetTenantId());
return(Ok(new { UserId = user.Id, Code = code }));
}
// If we got this far, something failed, redisplay form
return(BadRequest(Errors.GetErrorList(ModelState)));
}
public async Task <IActionResult> GetInformation()
{
try
{
var tenantId = _tenantProvider.GetTenantId();
var tenant = await _tenantProvider.GetTenant(tenantId);
return(Ok(tenant));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(BadRequest("Something went wrong."));
}
}
private void ProcessEntities()
{
var modifiedEntries = ChangeTracker.Entries()
.Where(x => x.State == EntityState.Added ||
x.State == EntityState.Modified ||
x.State == EntityState.Deleted);
if (modifiedEntries.Any())
{
var tenantId = _tenantProvider.GetTenantId();
foreach (var entry in modifiedEntries)
{
SetTenantIdIfNeeded(tenantId, entry);
}
}
}
public async Task <string> GetBaseUrl(string tenant)
{
var baseUrl = $"https://{_config["BaseUrlApi"]}";
if (tenant == null)
{
tenant = _tenantProvider.GetTenantId();
}
var getTenant = await _tenantService.GetTenant(tenant);
if (getTenant != null)
{
baseUrl = $"https://{getTenant.Id}.{_config["BaseUrlApi"]}";
}
return(baseUrl);
}
public async Task <ApplicationUser> EditUser(CreateUserViewModel model, bool isAdmin)
{
var user = await _userService.GetUserWithImageById(model.Id);
var getAdmin = await _userService.GetUserById(model.ProcessedById);
var admins = await _userService.ListAdmins();
var adminIds = admins.Select(a => a.Id).ToHashSet();
user.Email = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.Email + "_" + _tenantProvider.GetTenantId();
if (model.UserImage != null)
{
if (user.UserImage == null)
{
user.UserImage = new UserImage();
}
user.UserImage.UserImageStr = model.UserImage;
}
if (isAdmin)
{
user.UserDetail.InitialAuthorityPercent = model.InitialAuthorityPercent;
if (model.IsAdmin && !adminIds.Contains(model.Id))
{
await _userService.AssignRoleToUser(user.Id, "Admin", user.TenantId);
}
else if (!model.IsAdmin && adminIds.Contains(model.Id) && model.Id != model.ProcessedById)
{
await _userService.RemoveUserFromRole(user.Id, "Admin", user.TenantId);
}
}
user.UserDetail.LanguagePreference = getAdmin != null ? getAdmin.UserDetail.LanguagePreference : "tr";
await _userService.EditUser(user);
return(user);
}
public static bool TryGetTenantId <T>(this ITenantProvider tenantIdProvider, out T?value, T?defaultValue = default)
{
try
{
var tenantId = tenantIdProvider.GetTenantId();
if (!string.IsNullOrEmpty(tenantId))
{
value = tenantId.To <T>();
return(true);
}
}
catch (Exception)
{
// ignored
}
value = defaultValue;
return(false);
}
public async Task <PolicyChangePoll> NewPolicyChangePoll(PolicyChangePollViewModel model)
{
var poll = new PolicyChangePoll
{
UserId = model.UserId,
CreateTime = DateTime.UtcNow,
Active = true,
Name = model.Name,
QuestionBody = model.Description,
TenantId = _tenantProvider.GetTenantId(),
PolicyId = model.PolicyId
};
await _pollService.AddPoll(poll);
return(poll);
}
public DbConnection OpenDDRConnection()
{
var connectionString = _configuration.GetConnectionString("ShardMapManager");
SqlConnectionStringBuilder connStrBldr = new SqlConnectionStringBuilder(connectionString);
SqlConnectionStringBuilder emptyCon = new SqlConnectionStringBuilder
{
UserID = connStrBldr.UserID,
Password = connStrBldr.Password,
ApplicationName = connStrBldr.ApplicationName
};
ShardMapManager smm;
if (!ShardMapManagerFactory.TryGetSqlShardMapManager(connStrBldr.ConnectionString, ShardMapManagerLoadPolicy.Lazy, out smm))
{
return(null);
}
ListShardMap <long> shardMap;
if (!smm.TryGetListShardMap <long>(ElasticScaleConstants.ListMapName, out shardMap))
{
return(null);
}
var tenantId = _tenantProvider.GetTenantId();
SqlConnection conn = shardMap.OpenConnectionForKey(tenantId, emptyCon.ConnectionString, ConnectionOptions.Validate);
SqlCommand cmd = conn.CreateCommand();
cmd.CommandText = @"SET CONTEXT_INFO " + tenantId;
cmd.CommandType = System.Data.CommandType.Text;
cmd.ExecuteNonQuery();
return(conn);
}
static void AddTenantIdFilter <T, EntityKey>(ModelBuilder modelBuilder, ITenantProvider tenantProvider) where T : DomainEntity <EntityKey>
{
modelBuilder.Entity <T>().HasQueryFilter(entity => EF.Property <int>(entity, "TenantId") == tenantProvider.GetTenantId());
}
public async Task <IActionResult> SendEmailToNotVotedUsers(int pollId)
{
try
{
var poll = await _pollService.GetPoll(pollId);
var user = await _userService.GetUserById(User.ApiGetUserId());
if (poll == null)
{
ModelState.AddModelError("", _localizer["PollNotFound"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
if (!poll.Active)
{
ModelState.AddModelError("", _localizer["PollCompleted"]);
return(BadRequest(Errors.GetErrorList(ModelState)));
}
var msg =
$"{user.FirstName} {user.LastName} {_localizer["NamedUser"]} <a href='{await _genericService.GetBaseUrl(null)}/polls'>{poll.Name}</a> {_localizer["InvitedYouToVote"]}.";
BackgroundJob.Enqueue(() => _pollService.SendDirectEmailToNotVotedUsers(_tenantProvider.GetTenantId(),
_localizer["PollInvitation"], msg, pollId));
return(Ok(true));
}
catch (Exception)
{
return(Ok(false));
}
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.ApplyConfiguration(new PermissionEntityTypeConfiguration());
modelBuilder.ApplyConfiguration(new DeviceEntityTypeConfiguration());
modelBuilder.ApplyConfiguration(new DeviceEntityTypeConfiguration.DeviceTagEntityTypeConfiguration());
modelBuilder.ApplyConfiguration(new DeviceEntityTypeConfiguration.ProductEntityTypeConfiguration());
foreach (var item in modelBuilder.Model.GetEntityTypes())
{
// 多租户
if (item.ClrType.IsAssignableTo(typeof(IMultiTenant)))
{
modelBuilder.Entity(item.ClrType).AddQueryFilter <IMultiTenant>(e => e.TenantId == _tenantProvider.GetTenantId());
}
// 软删除
if (item.ClrType.IsAssignableTo(typeof(ISoftDelete)))
{
modelBuilder.Entity(item.ClrType).AddQueryFilter <ISoftDelete>(e => !e.Deleted);
}
}
}
private string GetTenantId() => tenantProvider.GetTenantId <T>();
/// <summary>
/// 构造
/// </summary>
/// <param name="options"></param>
/// <param name="mediator"></param>
/// <param name="capBus"></param>
public MessageContext(DbContextOptions options, IMediator mediator, ICapPublisher capBus, ITenantProvider tenantProvider) : base(options, mediator, capBus)
{
_tenantId = tenantProvider.GetTenantId();
}
public static T?GetTenantId <T>(this ITenantProvider tenantIdProvider, T?defaultValue = default)
{
return(tenantIdProvider.GetTenantId().ToOrDefault(defaultValue));
}
public BloggingContext(DbContextOptions <BloggingContext> options, ITenantProvider tenantProvider)
: base(options)
{
_tenantId = tenantProvider.GetTenantId();
}
