public override int SaveChanges()
{
var entities = from e in ChangeTracker.Entries()
where e.State == EntityState.Added ||
e.State == EntityState.Modified
select e.Entity;
bool error = false;
Collection <ValidationResult> validationResults = new Collection <ValidationResult>();
foreach (var entity in entities)
{
var validationContext = new ValidationContext(entity);
//Validator.ValidateObject(entity, validationContext);
if (Validator.TryValidateObject(entity, validationContext, validationResults, true))
{
error = true;
}
}
if (error == true)
{
int counter = 0;
string wholeMessage = "Error while validating Entities:" + Environment.NewLine;
foreach (var valResult in validationResults)
{
counter++;
string msg = "Members " + valResult.MemberNames.Aggregate((a, b) => a + ", " + b) + " not valid: ";
msg += valResult.ErrorMessage;
wholeMessage += msg + Environment.NewLine;
}
var ex = new HubException(wholeMessage);
throw ex;
}
return(base.SaveChanges());
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'AccountController.Logout()'
public async Task <ActionResult <bool> > Logout()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'AccountController.Logout()'
{
try
{
//var user = _userManager.FindByEmailAsync(email).Result;
//var user = await _signInManager.UserManager.GetUserAsync(User);
await _signInManager.SignOutAsync();
return(Ok(true));
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
//var tc = new Microsoft.ApplicationInsights.TelemetryClient();
ExceptionTelemetry et = new ExceptionTelemetry(e);
et.Properties.Add("user", User.Identity.Name);
tc.TrackException(et);
}
catch (Exception ex)
{
_logger?.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
public async Task <ActionResult <List <String> > > GetRoles()
{
try
{
//var user = _userManager.FindByEmailAsync(email).Result;
var user = await _signInManager.UserManager.GetUserAsync(User);
if (user.EmailConfirmed)
{
await SeedData.EnsureRole(Program.MyHost.Services, user.Id, API.Authorizarion.Constants.UserRoleConfirmed, _roleManager, _userManager);
}
var roles = await _userManager.GetRolesAsync(user);
return(Ok(roles.ToList()));
}
catch (Exception e)
{
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'SINSearchController.AdminGetSINners()'
public async Task <IEnumerable <SINner> > AdminGetSINners()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'SINSearchController.AdminGetSINners()'
{
try
{
_logger.LogTrace("AdminGetIds");
var result = await(from a in _context.SINners.Include(sinner => sinner.SINnerMetaData)
.ThenInclude(meta => meta.Visibility)
.ThenInclude(vis => vis.UserRights)
.Include(meta => meta.SINnerMetaData)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
select a).ToListAsync();
return(result);
}
catch (Exception e)
{
HubException hue = new HubException("Exception in AdminGetIds: " + e.Message, e);
throw hue;
}
}
public IEnumerable <SINner> Get()
{
try
{
_logger.LogTrace("Getting SINner");
var result = _context.SINners.OrderByDescending(a => a.UploadDateTime).Take(20);
result = _context.SINners.Include(sinner => sinner.SINnerMetaData)
.ThenInclude(meta => meta.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.ThenInclude(tag => tag.Tags)
.Include(a => a.SINnerMetaData.Visibility.UserRights)
.OrderByDescending(a => a.UploadDateTime).Take(20);
return(result);
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in GetSINner: " + e.Message, e);
throw hue;
}
}
public async Task <ActionResult <SINSearchGroupResult> > GetSearchGroups(string Groupname, string UsernameOrEmail, string SINnerName, string Language)
{
_logger.LogTrace("GetSearchGroups: " + Groupname + "/" + UsernameOrEmail + "/" + SINnerName + ".");
try
{
return(await GetSearchGroupsInternal(Groupname, UsernameOrEmail, SINnerName, Language));
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry(e);
telemetry.Properties.Add("User", user?.Email);
tc.TrackException(telemetry);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in GetSearchGroups: " + e.Message, e);
return(BadRequest(hue));
}
}
public async Task <ActionResult <string> > GetDeleteAndRecreateDb()
{
try
{
#if DEBUG
System.Diagnostics.Trace.TraceInformation("Users is NOT checked in Debug!");
#else
var user = await _signInManager.UserManager.GetUserAsync(User);
if (user == null)
{
return(Unauthorized());
}
var roles = await _userManager.GetRolesAsync(user);
if (!roles.Contains("Administrator"))
{
return(Unauthorized());
}
#endif
await _context.Database.EnsureDeletedAsync();
Program.Seed();
return(Ok("Database recreated"));
}
catch (Exception e)
{
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
private async Task <SINner> CheckIfUpdateSINnerFile(Guid id, ApplicationUser user)
{
try
{
bool admin = false;
var roles = await _userManager.GetRolesAsync(user);
foreach (var role in roles)
{
if (role.ToUpperInvariant() == "Administrator".ToUpperInvariant())
{
admin = true;
break;
}
}
var dbsinner = await _context.SINners.Include(a => a.SINnerMetaData.Visibility.UserRights)
.Include(b => b.MyGroup)
.FirstOrDefaultAsync(e => e.Id == id);
if (dbsinner != null)
{
var editseq = (from a in dbsinner.SINnerMetaData.Visibility.UserRights where a.EMail.ToUpperInvariant() == user.NormalizedEmail select a).ToList();
foreach (var edit in editseq)
{
if (edit.CanEdit == true)
{
return(dbsinner);
}
}
if (admin)
{
return(dbsinner);
}
if (dbsinner.MyGroup != null)
{
if (!String.IsNullOrEmpty(dbsinner.MyGroup.MyAdminIdentityRole))
{
var localadmins = await _userManager.GetUsersInRoleAsync(dbsinner.MyGroup.MyAdminIdentityRole);
if (localadmins.Contains(user))
{
return(dbsinner);
}
}
}
throw new ChummerHub.NoUserRightException(user.UserName, dbsinner.Id);
}
return(null);
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in CheckIfUpdateSINnerFile: " + e.Message, e);
throw hue;
}
}
public async Task UserCannotSendMessageInNotHisChat()
{
HubException exception = null;
var connection = (await new HubConnectionBuilder()
.WithUrl(_uri, TestData.User.Email, TestData.User.Password))
.Build();
await connection.StartAsync();
connection.On <MessageResponse>("SendMessage", res => { });
try
{
await connection.InvokeAsync("SendMessage", new SendMessageRequest()
{
ChatId = 7,
Message = "Hello"
});
}
catch (HubException e)
{
exception = e;
}
exception.Should().NotBeNull();
exception?.Message.Should().BeEquivalentTo("An unexpected error occurred invoking 'SendMessage' on the server.");
}
public async Task <ActionResult <ApplicationUser> > PostSetUserRole(string email, string userrole)
{
try
{
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(NotFound());
}
await SeedData.EnsureRole(Program.MyHost.Services, user.Id, userrole, _roleManager, _userManager);
user.PasswordHash = "";
user.SecurityStamp = "";
return(Ok(user));
}
catch (Exception e)
{
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'AccountController.GetDeleteAllSINnersDb()'
public async Task <ActionResult <string> > GetDeleteAllSINnersDb()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'AccountController.GetDeleteAllSINnersDb()'
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
if (user == null)
{
return(Unauthorized());
}
var roles = await _userManager.GetRolesAsync(user);
if (!roles.Contains("Administrator"))
{
return(Unauthorized());
}
var count = await _context.SINners.CountAsync();
using (var transaction = await _context.Database.BeginTransactionAsync())
{
_context.UserRights.RemoveRange(_context.UserRights.ToList());
_context.SINnerComments.RemoveRange(_context.SINnerComments.ToList());
_context.Tags.RemoveRange(_context.Tags.ToList());
_context.SINnerVisibility.RemoveRange(_context.SINnerVisibility.ToList());
_context.SINnerMetaData.RemoveRange(_context.SINnerMetaData.ToList());
_context.SINners.RemoveRange(_context.SINners.ToList());
_context.UploadClients.RemoveRange(_context.UploadClients.ToList());
await _context.SaveChangesAsync();
// Commit transaction if all commands succeed, transaction will auto-rollback
// when disposed if either commands fails
await transaction.CommitAsync();
}
return(Ok("Reseted " + count + " SINners"));
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
//var tc = new Microsoft.ApplicationInsights.TelemetryClient();
ExceptionTelemetry et = new ExceptionTelemetry(e);
et.Properties.Add("user", User.Identity.Name);
tc.TrackException(et);
}
catch (Exception ex)
{
_logger?.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
public async Task <ActionResult <bool> > DeleteLeaveGroup(Guid groupid, Guid sinnerid)
{
_logger.LogTrace("DeleteLeaveGroup: " + groupid + "/" + sinnerid + ".");
try
{
return(await DeleteLeaveGroupInternal(groupid, sinnerid));
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry(e);
telemetry.Properties.Add("User", user?.Email);
tc.TrackException(telemetry);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in DeleteLeaveGroup: " + e.Message, e);
return(BadRequest(hue));
}
}
public async Task StartShouldFailIfTransportStartCompletesAfterDisconnect()
{
var connection = new Client.Connection("http://test");
var transport = new Mock <IClientTransport>();
var innerHubException = new HubException();
transport.Setup(m => m.Negotiate(connection, It.IsAny <string>()))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = connection.Protocol.ToString(),
ConnectionId = "Something",
DisconnectTimeout = 120,
KeepAliveTimeout = 30,
}));
transport.Setup(m => m.Start(connection, null, It.IsAny <CancellationToken>()))
.Callback(() =>
{
Assert.Equal(ConnectionState.Connecting, connection.State);
// This emulates receiving a global error from the server right before
// IClientTransport.Start() completes successfully.
((IConnection)connection).OnError(innerHubException);
((IConnection)connection).Disconnect();
})
.Returns(TaskAsyncHelper.Empty);
var startEx = await Assert.ThrowsAsync <StartException>(async() => await connection.Start(transport.Object));
Assert.Equal(Resources.Error_ConnectionCancelled, startEx.Message);
Assert.Same(innerHubException, startEx.InnerException);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public async Task <ActionResult <SINnerGroup> > GetGroupById(Guid groupid)
{
_logger.LogTrace("GetById: " + groupid + ".");
try
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
string msg = "ModelState is invalid: ";
foreach (var err in errors)
{
foreach (var singleerr in err)
{
msg += Environment.NewLine + "\t" + singleerr.ToString();
}
}
return(BadRequest(new HubException(msg)));
}
var groupfoundseq = await(from a in _context.SINnerGroups
.Include(a => a.MySettings)
.Include(a => a.MyGroups)
.ThenInclude(b => b.MyGroups)
.ThenInclude(b => b.MyGroups)
where a.Id == groupid select a).ToListAsync();
if (!groupfoundseq.Any())
{
return(NotFound(groupid));
}
var group = groupfoundseq.FirstOrDefault();
group.PasswordHash = null;
return(Ok(group));
}
catch (Exception e)
{
try
{
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry(e);
telemetry.Properties.Add("groupid", groupid.ToString());
tc.TrackException(telemetry);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in GetGroupById: " + e.Message, e);
return(BadRequest(hue));
}
}
public static string GetErrorMessage(this HubException hubException)
{
// SignalR's HubExceptions' messages are formatted as "An unexpected error occurred invoking 'Method' on the server. HubException: ...".
// This strips the first part, getting the hub's actual error message.
int errorMessageStart = hubException.Message.IndexOf(ErrorMessageStartFlag, StringComparison.OrdinalIgnoreCase) + ErrorMessageStartFlag.Length;
return(hubException.Message.Substring(errorMessageStart));
}
public async Task <FileResult> GetDownloadFile([FromRoute] Guid sinnerid)
{
try
{
if (!ModelState.IsValid)
{
throw new ArgumentException("ModelState is invalid!");
}
var chummerFile = await _context.SINners.FindAsync(sinnerid);
if (chummerFile == null)
{
throw new ArgumentException("Could not find id " + sinnerid.ToString());
}
if (String.IsNullOrEmpty(chummerFile.DownloadUrl))
{
string msg = "Chummer " + chummerFile.Id + " does not have a valid DownloadUrl!";
throw new ArgumentException(msg);
}
//string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.InternetCache), chummerFile.Id.ToString() + ".chum5z");
var stream = await MyHttpClient.GetStreamAsync(new Uri(chummerFile.DownloadUrl));
string downloadname = chummerFile.Id.ToString() + ".chum5z";
var user = await _signInManager.UserManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
throw new NoUserRightException("User not found!");
}
try
{
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.EventTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.EventTelemetry("GetDownloadFile");
telemetry.Properties.Add("User", user.Email);
telemetry.Properties.Add("SINnerId", sinnerid.ToString());
telemetry.Metrics.Add("FileSize", stream.Length);
tc.TrackEvent(telemetry);
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
return(new FileStreamResult(stream, new Microsoft.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream"))
{
FileDownloadName = downloadname
});
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in GetDownloadFile: " + e.Message, e);
throw hue;
}
}
public async Task <ActionResult <SINSearchGroupResult> > GetGroupMembers(Guid groupid)
{
_logger.LogTrace("GetGroupMembers: " + groupid + ".");
try
{
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
string msg = "ModelState is invalid: ";
foreach (var err in errors)
{
foreach (var singleerr in err)
{
msg += Environment.NewLine + "\t" + singleerr.ToString();
}
}
return(BadRequest(new HubException(msg)));
}
SINSearchGroupResult result = new SINSearchGroupResult();
var range = await GetSinSearchGroupResultById(groupid);
result.SINGroups.Add(range);
result.SINGroups = RemovePWHashRecursive(result.SINGroups);
Ok(result);
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry(e);
telemetry.Properties.Add("User", user?.Email);
telemetry.Properties.Add("groupid", groupid.ToString());
tc.TrackException(telemetry);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in GetSearchGroups: " + e.Message, e);
return(BadRequest(hue));
}
return(BadRequest());
}
public async Task <IActionResult> Delete([FromRoute] Guid id)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var sinner = await _context.SINners.Include(a => a.SINnerMetaData.Visibility.UserRights).FirstOrDefaultAsync(a => a.Id == id);
if (sinner == null)
{
return(NotFound());
}
var user = await _signInManager.UserManager.FindByNameAsync(User.Identity.Name);
var dbsinner = await CheckIfUpdateSINnerFile(id, user);
if (dbsinner == null)
{
return(BadRequest("not authorized"));
}
var olduserrights = await(from a in _context.UserRights where a.SINnerId == sinner.Id select a).ToListAsync();
_context.UserRights.RemoveRange(olduserrights);
var oldtags = await(from a in _context.Tags where a.SINnerId == sinner.Id select a).ToListAsync();
_context.Tags.RemoveRange(oldtags);
var oldsinners = await(from a in _context.SINners where a.Id == sinner.Id select a).ToListAsync();
foreach (var oldsin in oldsinners)
{
if (_context.SINnerVisibility.Contains(oldsin.SINnerMetaData.Visibility))
{
_context.SINnerVisibility.Remove(oldsin.SINnerMetaData.Visibility);
}
if (_context.SINnerMetaData.Contains(oldsin.SINnerMetaData))
{
_context.SINnerMetaData.Remove(oldsin.SINnerMetaData);
}
}
_context.SINners.RemoveRange(oldsinners);
await _context.SaveChangesAsync();
return(Ok("deleted"));
}
catch (Exception e)
{
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in DeleteSINnerFile: " + e.Message, e);
return(BadRequest(hue));
}
}
private bool UploadClientExists(Guid id)
{
try
{
return(_context.UploadClients.Any(e => e.Id == id));
}
catch (Exception e)
{
HubException hue = new HubException("Exception in UploadClientExists: " + e.Message, e);
throw hue;
}
}
public async Task <ActionResult <ChummerHubVersion> > GetVersion()
{
try
{
return(Ok(new ChummerHubVersion()));
}
catch (Exception e)
{
HubException hue = new HubException("Exception in GetVersion: " + e.Message, e);
return(StatusCode(500, hue));
}
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'AccountController.GetDeleteAndRecreateDb()'
public async Task <ActionResult <string> > GetDeleteAndRecreateDb()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'AccountController.GetDeleteAndRecreateDb()'
{
try
{
#if DEBUG
System.Diagnostics.Trace.TraceInformation("Users is NOT checked in Debug!");
#else
var user = await _signInManager.UserManager.GetUserAsync(User);
if (user == null)
{
return(Unauthorized());
}
var roles = await _userManager.GetRolesAsync(user);
if (!roles.Contains("Administrator"))
{
return(Unauthorized());
}
#endif
await _context.Database.EnsureDeletedAsync();
Program.Seed();
return(Ok("Database recreated"));
}
catch (Exception e)
{
try
{
var user = await _signInManager.UserManager.GetUserAsync(User);
//var tc = new Microsoft.ApplicationInsights.TelemetryClient();
ExceptionTelemetry et = new ExceptionTelemetry(e);
et.Properties.Add("user", User.Identity.Name);
tc.TrackException(et);
}
catch (Exception ex)
{
if (_logger != null)
{
_logger.LogError(ex.ToString());
}
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException(e.Message, e);
return(BadRequest(hue));
}
}
public async Task <ActionResult <SINner> > GetSINById([FromRoute] Guid id)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _signInManager.UserManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(BadRequest("Could not find user: "******"SINner with id " + id + " does not exist."));
}
if (sin.SINnerMetaData.Visibility.IsPublic == true)
{
return(Ok(sin));
}
var list = (from a in sin.SINnerMetaData.Visibility.UserRights where a.EMail.ToUpperInvariant() == user.NormalizedEmail select a);
if (list.Any())
{
return(Ok(sin));
}
throw new NoUserRightException("SINner is not viewable for public or groupmembers.");
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in GetSINById: " + e.Message, e);
throw hue;
}
}
public async Task <ActionResult <SINner> > PutSINerInGroup(Guid GroupId, Guid SinnerId, string pwhash)
{
_logger.LogTrace("PutSINerInGroup: " + GroupId + " (" + SinnerId + ").");
ApplicationUser user = null;
try
{
user = await _signInManager.UserManager.GetUserAsync(User);
if (!ModelState.IsValid)
{
var errors = ModelState.Select(x => x.Value.Errors)
.Where(y => y.Count > 0)
.ToList();
string msg = "ModelState is invalid: ";
foreach (var err in errors)
{
foreach (var singleerr in err)
{
msg += Environment.NewLine + "\t" + singleerr.ToString();
}
}
return(BadRequest(new HubException(msg)));
}
var roles = await _userManager.GetRolesAsync(user);
var sin = await PutSiNerInGroupInternal(GroupId, SinnerId, user, _context, _logger, pwhash, roles);
return(Ok(sin));
}
catch (Exception e)
{
try
{
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry telemetry = new Microsoft.ApplicationInsights.DataContracts.ExceptionTelemetry(e);
telemetry.Properties.Add("User", user?.Email);
telemetry.Properties.Add("GroupId", GroupId.ToString());
tc.TrackException(telemetry);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
}
if (e is HubException)
{
return(BadRequest(e));
}
HubException hue = new HubException("Exception in PutSINerInGroup: " + e.Message, e);
return(BadRequest(hue));
}
}
//public Object PayLoad { get; set; }
public ResultBase(Exception e)
{
if (e is HubException exception)
{
MyException = exception;
}
else
{
MyException = new HubException(e.Message, e);
}
CallSuccess = false;
ErrorText = e.Message;
}
#pragma warning disable CS1998 // This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'ChummerHelper.GetVersion()'
public async Task <ActionResult <ChummerHubVersion> > GetVersion()
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'ChummerHelper.GetVersion()'
#pragma warning restore CS1998 // This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await Task.Run(...)' to do CPU-bound work on a background thread.
{
try
{
return(Ok(new ChummerHubVersion()));
}
catch (Exception e)
{
HubException hue = new HubException("Exception in GetVersion: " + e.Message, e);
return(StatusCode(500, hue));
}
}
private static string GetHubExceptionMessage(HubException exception)
{
var exceptionMessage = exception.Message;
if (string.IsNullOrEmpty(exceptionMessage))
{
return(exceptionMessage);
}
var messagePrefix = "HubException: ";
var index = exceptionMessage.IndexOf(messagePrefix, StringComparison.OrdinalIgnoreCase);
return(index < 0 ? exceptionMessage : exceptionMessage.Substring(index + messagePrefix.Length));
}
public async Task <ActionResult <SINner> > GetById([FromRoute] Guid id)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var sin = await _context.SINners.Include(a => a.SINnerMetaData.Visibility.UserRights).FirstOrDefaultAsync(a => a.Id == id);
if (sin == null)
{
return(NotFound());
}
if (sin.SINnerMetaData.Visibility.IsPublic == true)
{
return(Ok(sin));
}
var user = await _signInManager.UserManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(BadRequest("Could not find user: "******"not authorized"));
}
catch (Exception e)
{
HubException hue = new HubException("Exception in GetSINnerfile: " + e.Message, e);
return(BadRequest(hue));
}
}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'ResultBase.ErrorText'
//public Object PayLoad { get; set; }
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member 'ResultBase.ResultBase(Exception)'
public ResultBase(Exception e)
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member 'ResultBase.ResultBase(Exception)'
{
if (e is HubException exception)
{
MyException = exception;
}
else
{
MyException = new HubException(e.Message, e);
}
CallSuccess = false;
ErrorText = e.Message;
}
public async Task <ActionResult <List <SINner> > > GetOwnedSINByAlias([FromRoute] string id)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser user = null;
if (!String.IsNullOrEmpty(User?.Identity?.Name))
{
user = await _signInManager.UserManager.FindByNameAsync(User.Identity.Name);
}
var sinseq = await _context.SINners
.Include(a => a.MyExtendedAttributes)
.Include(a => a.SINnerMetaData.Visibility.UserRights)
.Include(a => a.MyGroup)
.Include(b => b.MyGroup.MySettings)
.Where(a => a.Alias == id).ToListAsync();
if (!sinseq.Any())
{
return(NotFound("SINner with Alias " + id + " does not exist."));
}
List <SINner> download = new List <SINner>();
foreach (var sin in sinseq)
{
if ((user != null &&
sin.SINnerMetaData.Visibility.UserRights.Any(a =>
a.EMail.ToLowerInvariant() == user.Email.ToLowerInvariant())))
{
download.Add(sin);
}
}
return(Ok(download));
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in GetOwnedSINByAlias: " + e.Message, e);
throw hue;
}
}
private async Task <SINner> CheckIfUpdateSINnerFile(Guid id, ApplicationUser user, bool allincludes = false)
{
try
{
return(await CheckIfUpdateSINnerFileInternal(id, user, allincludes));
}
catch (Exception e)
{
if (e is HubException)
{
throw;
}
HubException hue = new HubException("Exception in CheckIfUpdateSINnerFile: " + e.Message, e);
throw hue;
}
}
