private static async Task InitliazeDb()
{
using (var context = new BakaContext())
{
await context.Database.EnsureCreatedAsync();
var root_user = await context.Users.FirstOrDefaultAsync(x => x.Token == Config.RootToken);
if (root_user != null)
{
Console.WriteLine("Root user already exists!\n" + JsonConvert.SerializeObject(root_user));
return;
}
root_user = new BakaUser()
{
Name = "ROOT_USER",
Username = "******",
InitialIp = "ROOT_USER",
UploadLimitMB = 500,
Deleted = false,
Disabled = false,
Timestamp = DateTime.Now,
Email = "ROOT_USER_DO_NOT_USE_FOR_UPLOADING_OBJECTS",
Token = Config.RootToken,
AccountType = "su_full"
};
await context.Users.AddAsync(root_user);
await context.SaveChangesAsync();
Console.WriteLine("Created root user!\n" + JsonConvert.SerializeObject(root_user));
}
}
public async Task <IActionResult> GetUserInfo(string token)
{
try
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
using (var context = new BakaContext())
{
BakaUser return_usr = await context.Users.FirstOrDefaultAsync(x => x.Token == token);
if (return_usr == null)
{
return(NotFound(new { success = false, error = "404 Not Found", code = 404 }));
}
return(Json(new
{
id = return_usr.Id,
username = return_usr.Username,
name = return_usr.Name,
email = return_usr.Email,
upload_limit = return_usr.UploadLimitMB,
initial_ip = return_usr.InitialIp,
timestamp = return_usr.Timestamp.ToFileTimeUtc().ToString(),
token = return_usr.Token,
deleted = return_usr.Deleted,
disabled = return_usr.Disabled,
account_type = return_usr.AccountType,
links = return_usr.Links,
files = return_usr.Files,
}));
}
}
catch
{
Response.StatusCode = 500;
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
}
public async Task <IActionResult> DeleteUser(string token)
{
try
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
using (var context = new BakaContext())
{
BakaUser return_usr = await context.Users.FirstOrDefaultAsync(x => x.Token == token);
if (return_usr == null)
{
return(NotFound(new { success = false, error = "404 Not Found", code = 404 }));
}
if (!Globals.Config.PreserveDeletedFiles)
{
context.Users.Remove(return_usr);
}
else
{
return_usr.Deleted = true;
}
await context.SaveChangesAsync();
return(Json(new
{
success = true,
code = 200,
deleted = true
}));
}
}
catch
{
Response.StatusCode = 500;
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
}
public async Task <IActionResult> ResetUserToken(string token)
{
try
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
using (var context = new BakaContext())
{
BakaUser return_usr = await context.Users.FirstOrDefaultAsync(x => x.Token == token);
if (return_usr == null)
{
return(NotFound(new
{
success = false,
error = "404 Not Found",
code = 404
}));
}
return_usr.Token = Globals.GenerateToken(return_usr);
await context.SaveChangesAsync();
return(Json(new
{
new_token = return_usr.Token
}));
}
}
catch
{
Response.StatusCode = 500;
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
}
private async Task <IActionResult> GetLink(string name, string ext, string url)
{
using (var context = new BakaContext())
{
var link = await context.Links.FirstOrDefaultAsync(u => u.ExternalId == name);
if (link == null)
{
return(null);
}
return(Redirect(link.Destination));
}
}
internal AuthModel Authorize(string type)
{
AuthModel model = new AuthModel();
var token = Request.Headers["baka_token"].FirstOrDefault();
if (string.IsNullOrWhiteSpace(token))
{
return(NullModel());
}
using (var context = new BakaContext())
{
var usr = context.Users.FirstOrDefault(u => u.Token == token);
if (usr == null)
{
return(NullModel());
}
if (usr.Disabled)
{
model.Authorized = false;
model.Reason = "Your account has been disabled";
}
else if (usr.Deleted)
{
model.Reason = "Invalid token";
}
else if (usr.AccountType != type)
{
model.Authorized = false;
model.Reason = "Missing permissions";
}
else
{
model.Authorized = true;
}
model.User = usr;
return(model);
}
}
public async Task <IActionResult> GetFileOrLink(string name, string ext, string url)
{
using (var context = new BakaContext())
{
Console.WriteLine(name + " || " + ext);
var file = await context.Files.FirstOrDefaultAsync(u => u.ExternalId == name);
if (file == null || file.Deleted)
{
IActionResult link = await GetLink(name, ext, url);
if (link != null)
{
return(link);
}
Response.StatusCode = 404;
return(Json(new
{
success = false,
error = "Object not found",
code = 404
}));
}
string file_ext = Path.GetExtension(file.Filename);
string use_url_extention = Request.Query["u"].FirstOrDefault() ?? "0";
if (use_url_extention == "1" || use_url_extention == "true")
{
file_ext = ext;
}
return(File(await Globals.GetFile(file.BackendFileId), BakaMime.GetMimeType(file_ext)));
}
}
public async Task <IActionResult> CreateUser([FromBody] NewUserModel details)
{
try
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
BakaUser return_usr;
using (var context = new BakaContext())
{
var usr = new BakaUser()
{
Name = details.Name,
Username = details.Username,
Email = details.Email,
InitialIp = null,
Timestamp = DateTime.Now,
UploadLimitMB = details.UploadLimit,
Deleted = false,
Disabled = false,
AccountType = "su_upload"
};
usr.Token = Globals.GenerateToken(usr);
await context.Users.AddAsync(usr);
await context.SaveChangesAsync();
return_usr = usr;
}
return(Json(new
{
id = return_usr.Id,
username = return_usr.Username,
name = return_usr.Name,
initial_ip = return_usr.InitialIp,
timestamp = return_usr.Timestamp.ToFileTimeUtc().ToString(),
token = return_usr.Token,
deleted = return_usr.Deleted,
disabled = return_usr.Disabled,
email = return_usr.Email,
upload_limit = return_usr.UploadLimitMB,
}));
}
catch (Exception e)
{
Response.StatusCode = 500;
if (!Globals.Config.IsDebug)
{
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500,
exception = e.ToString(),
}));
}
}
public async Task <IActionResult> UploadFile([FromForm(Name = "file")] List <IFormFile> files)
{
AuthModel model = Authorize("su_upload");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
IFormFile file;
if (files == null || !files.Any() || files.FirstOrDefault() == null)
{
Response.StatusCode = 400;
return(Json(new
{
success = false,
code = 400,
error = "Uploads must be sent as 'file' and not be empty",
result_id = "e-400"
}));
}
else
{
file = files.FirstOrDefault();
}
double FileSize = Globals.ConvertBytesToMegabytes(file.Length);
if (FileSize > model.User.UploadLimitMB)
{
Response.StatusCode = 400;
return(Json(new
{
success = false,
code = 400,
error = "Exceeds max file size",
max_file_size = model.User.UploadLimitMB,
global_limit = false,
result_id = "e-400"
}));
}
string extension = Path.GetExtension(file.FileName);
if (!extension.StartsWith("."))
{
extension = "." + extension;
}
BakaFile db_file = new BakaFile()
{
FileSizeMB = FileSize,
Filename = file.FileName,
Deleted = false,
ExternalId = Globals.GenerateFileId(),
BackendFileId = Globals.Config.S3KeyPrefix + Globals.GenerateBackendId() + extension,
Timestamp = DateTime.Now,
Extension = extension,
IpUploadedFrom = GetIp()
};
await Globals.UploadFile(file.OpenReadStream(), db_file.BackendFileId, db_file.ContentType);
using (var context = new BakaContext())
{
var user = await context.Users.FirstOrDefaultAsync(x => x.Id == model.User.Id);
user.Files.Add(db_file);
if (user.InitialIp == null)
{
string ip = GetIp();
user.InitialIp = ip;
}
await context.SaveChangesAsync();
}
return(Json(new
{
id = db_file.Id,
result_id = db_file.ExternalId,
full_result_id = db_file.ExternalId + db_file.Extension,
file_size = FileSize,
timestamp = db_file.Timestamp.ToFileTimeUtc().ToString(),
file_name = db_file.Filename,
success = true,
code = 200
}));
}
public async Task <IActionResult> GetUserFromId(int id)
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
try
{
using (var context = new BakaContext())
{
BakaUser return_usr = await context.Users.Include(x => x.Links).Include(x => x.Files).FirstOrDefaultAsync(x => x.Id == id);
if (return_usr == null)
{
return(NotFound(new { success = false, error = "404 Not Found", code = 404 }));
}
return(Json(new
{
id = return_usr.Id,
username = return_usr.Username,
name = return_usr.Name,
email = return_usr.Email,
upload_limit = return_usr.UploadLimitMB,
initial_ip = return_usr.InitialIp,
timestamp = return_usr.Timestamp.ToFileTimeUtc().ToString(),
token = return_usr.Token,
deleted = return_usr.Deleted,
disabled = return_usr.Disabled,
account_type = return_usr.AccountType,
links = return_usr.Links.ToList(),
files = return_usr.Files.ToList(),
}));
}
}
catch (Exception e)
{
Response.StatusCode = 500;
if (!Globals.Config.IsDebug)
{
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500,
exception = e.ToString(),
}));
}
}
public async Task <IActionResult> GetUsersList()
{
try
{
AuthModel model = Authorize("su_full");
if (!model.Authorized)
{
Response.StatusCode = 401;
return(Json(new
{
success = false,
error = model.Reason,
code = 401
}));
}
using (var context = new BakaContext())
{
var users = await context.Users.Include(x => x.Files).Include(x => x.Links).ToListAsync();
var usr_list = new List <dynamic>();
foreach (var usr in users)
{
var temp_usr = new
{
id = usr.Id,
username = usr.Username,
name = usr.Name,
email = usr.Email,
upload_limit = usr.UploadLimitMB,
initial_ip = usr.InitialIp,
timestamp = usr.Timestamp.ToFileTimeUtc().ToString(),
token = usr.Token,
deleted = usr.Deleted,
disabled = usr.Disabled,
account_type = usr.AccountType,
links = usr.Links.ToList(),
files = usr.Files.ToList(),
};
usr_list.Add(temp_usr);
}
return(Json(new
{
users = usr_list
}));
}
}
catch (Exception e)
{
Response.StatusCode = 500;
if (!Globals.Config.IsDebug)
{
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500
}));
}
return(Json(new
{
success = false,
error = "500 Internal Server Error",
code = 500,
exception = e.ToString(),
}));
}
}
