private async Task <IActionResult> ExportPoints <T>(int groupid) where T : class
{
try
{
using (NHibernate.IStatelessSession session = sessionFactory.OpenStatelessSession())
{
//DigitalOutputGroup s;s.
var @object = await session.CreateCriteria <T>().Add(Restrictions.Eq("Groupid", groupid)).ListAsync <T>();
if (@object == null || @object.Count == 0)
{
return(BadRequest(ApiResult.BadRequest($"ėģ GROUP ID {groupid}ź° ģ”“ģ¬ķģ§ ģģµėė¤")));
}
byte[] data = ExportCSVFormat <T>(@object);
string filename = $"{typeof(T).Name}.csv";
System.Net.Mime.ContentDisposition cd = new System.Net.Mime.ContentDisposition
{
FileName = Uri.EscapeUriString(filename),
Inline = false // false = prompt the user for downloading; true = browser to try to show the file inline
};
Response.Headers.Add("Content-Disposition", cd.ToString());
Response.Headers.Add("X-Content-Type-Options", "nosniff");
return(File(data, "application/octet-stream"));
}
}
catch (Exception ex)
{
return(BadRequest(ApiResult.BadRequest(ex.Message)));
}
}
public async Task <ApiResult> AddMember(int projectId, int userId)
{
bool projectExists = _projectService.ProjectExists(projectId);
if (!projectExists)
{
return(ApiResult.BadRequest("Project does not exist"));
}
//HACK: this works but is bad for performance since it gets the entire user object just to check if it exists
bool userExists = await _userManager.FindByIdAsync(userId.ToString()) != null;
if (!userExists)
{
return(ApiResult.BadRequest("User does not exist"));
}
bool userIsMember = _projectService.UserIsMember(projectId, userId);
if (userIsMember)
{
return(ApiResult.BadRequest("User is already member"));
}
_projectMemberService.CreateProjectMember(projectId, userId);
return(ApiResult.NoContent());
}
private async Task <IActionResult> Remove <T>(int id) where T : class
{
try
{
using (NHibernate.ISession session = sessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
//DigitalOutputGroup s;s.
var @object = await session.CreateCriteria <T>().Add(Restrictions.Eq("Id", id)).UniqueResultAsync <T>();
if (@object == null)
{
return(BadRequest(ApiResult.BadRequest($"ėģ ID {id}ź° ģ”“ģ¬ķģ§ ģģµėė¤")));
}
await session.DeleteAsync(@object);
await transaction.CommitAsync();
return(Ok(ApiResult.OK_200));
}
}
catch (Exception ex)
{
return(BadRequest(ApiResult.BadRequest(ex.Message)));
}
}
public async Task <ApiResult> ModifySelf(Core.Models.Users.User user)
{
var currentUser = await _userManager.GetUserAsync(User);
if (currentUser.Id != user.Id)
{
return(ApiResult.Forbidden("You do not have access to modify a different user using this endpoint."));
}
var oldUser = await _userManager.FindByIdAsync(user.Id.ToString());
if (oldUser == null)
{
return(ApiResult.BadRequest());
}
if (_userService.TryModifyUser(user, oldUser, out User newUser))
{
var userModel = _mapper.Map <Core.Models.Users.User>(newUser);
return(ApiResult.Success(userModel));
}
return(ApiResult.BadRequest());
}
public async Task <ApiResult> GetProfileByName(string username)
{
try
{
var profile = await _profileService.GetProfileByUsername(username);
if (profile == null)
{
return(ApiResult.NotFound("User was not found"));
}
var id = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
if (id == profile.Id)
{
profile.Self = true;
}
else
{
profile.Email = null;
}
return(ApiResult.Success(profile));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult <Like> > AddLikeUser(int userid, int likerid)
{
var like = await _likeBus.GetLike(userid, likerid);
if (like != null)
{
return(ApiResult <Like> .BadRequest("You already like this user"));
}
if (_likeBus.GetLike(likerid) == null)
{
return(ApiResult <Like> .NotFound("This user ws not found"));
}
like = new Like {
LikeeId = likerid, LikerId = userid
};
if (await _likeBus.AddLike(like))
{
return(ApiResult <Like> .Ok());
}
return(ApiResult <Like> .BadRequest("Failed to like user"));
}
public async Task <ApiResult> CreateAccount(string inviteCode, [FromBody] InvitePost invitePost)
{
var isValid = _userInviteService.IsValidInviteCode(inviteCode, out UserInvite invite);
if (!isValid)
{
return(ApiResult.BadRequest());
}
var result = await _userManager.CreateAsync(new User(invite.Username)
{
Email = invite.Email
}, invitePost.Password);
if (!result.Succeeded)
{
return(ApiResult.BadRequest());
}
var user = await _userManager.FindByNameAsync(invite.Username);
var role = await _roleManager.FindByIdAsync(invite.RoleId.ToString());
await _userManager.AddToRoleAsync(user, role.Name);
_userInviteService.RemoveInvite(invite.Id);
return(ApiResult.NoContent());
}
public async Task <ApiResult> PostUser([FromBody] UserPost userPost)
{
var role = await _roleManager.FindByIdAsync(userPost.RoleId.ToString());
if (role == null)
{
return(ApiResult.BadRequest());
}
var user = await _userManager.FindByNameAsync(userPost.Username);
//user with that username already exists
if (user != null)
{
return(ApiResult.BadRequest());
}
try
{
//check if the email is valid
if (new System.Net.Mail.MailAddress(userPost.Email).Address != userPost.Email)
{
return(ApiResult.BadRequest());
}
}
catch (Exception)
{
return(ApiResult.BadRequest());
}
_userInviteService.CreateInvite(userPost.Username, userPost.Email, userPost.RoleId);
return(ApiResult.NoContent());
}
public async Task <ApiResult> PostLogin(LoginMessage message)
{
User user = await _userService.LoginUser(message);
var userModel = _mapper.Map <Core.Models.User>(user);
return(userModel != null?ApiResult.Success(userModel) : ApiResult.BadRequest());
}
public async Task <ApiResult> ModifyProjectImage(int projectId)
{
if (await _projectService.TryModifyProjectImage(projectId, Request.Body, Request.ContentLength, Request.ContentType))
{
return(ApiResult.NoContent());
}
return(ApiResult.BadRequest());
}
public ApiResult GetSettings(string pluginKey)
{
var settings = _pluginSettingsManager.GetPluginSettings(pluginKey);
if (settings == null)
{
return(ApiResult.BadRequest());
}
return(ApiResult.Success(settings));
}
public async Task <ApiResult> ModifySelfAvatar()
{
var currentUser = await _userManager.GetUserAsync(User);
if (await _userService.TryModifyUserAvatar(currentUser, Request.Body, Request.ContentLength, Request.ContentType))
{
return(ApiResult.NoContent());
}
return(ApiResult.BadRequest());
}
public ApiResult SetSettings(string pluginKey, [FromBody] PluginData pluginSettings)
{
bool result = _pluginSettingsManager.SetPluginSettings(pluginKey, pluginSettings);
if (!result)
{
return(ApiResult.BadRequest());
}
return(ApiResult.NoContent());
}
public ApiResult GetUnapprovedTweets()
{
try
{
var tweets = _moderationService.GetProfanityTweetsByStatus(Status.Unapproved);
return(ApiResult.Success(tweets));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult <Like> > DeleteLikeUser(int userid, int likerid)
{
var like = new Like {
LikeeId = likerid, LikerId = userid
};
if (await _likeBus.DeleteLike(like))
{
return(ApiResult <Like> .Ok());
}
return(ApiResult <Like> .BadRequest("Failed to delete like user"));
}
public ApiResult GetFollowCounts(string id)
{
try
{
var result = _followService.GetFollowCount(id);
return(ApiResult.Success(result));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult> UpgradeUserToModerator(string userId)
{
try
{
var result = await _moderationService.UpgradeUserToModerator(userId);
return(result ? ApiResult.Success("User had been upgraded to admin.") : ApiResult.NotFound("Could not find user."));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult> UnApproveTweet(string tweetId)
{
try
{
var result = await _moderationService.UnApproveProfanityTweet(tweetId);
return(result ? ApiResult.Success("Tweet has been approved.") : ApiResult.NotFound("Could not find Tweet."));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public ApiResult GetTopTrends()
{
try
{
var topTrends = _trendingService.GetTopTrends();
return(ApiResult.Success(topTrends));
}
catch (Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public ApiResult RemoveMember(int projectId, int memberId)
{
var projectMember = _projectMemberService.GetProjectMember(projectId, memberId);
if (projectMember == null)
{
return(ApiResult.BadRequest());
}
_projectMemberService.RemoveProjectMember(projectMember);
return(ApiResult.NoContent());
}
public async Task <ApiResult> CreateTweet(CreateTweetMessage message)
{
try
{
var id = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
await _tweetService.CreateTweet(id, message.TweetContent);
return(ApiResult.Success("Created"));
}
catch (Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public ApiResult GetProfileTweets(string id)
{
try
{
var currentUserId = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var tweets = _tweetService.GetTweets(id, currentUserId);
return(ApiResult.Success(tweets));
}
catch (Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public ApiResult CheckIfFollows(string id)
{
try
{
var followerId = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var result = _followService.FollowExists(followerId, id);
return(ApiResult.Success(result));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult> AddMessageLike(int messageId)
{
var messageExists = _messageService.MessageExists(messageId);
if (!messageExists)
{
return(ApiResult.BadRequest("Message does not exist"));
}
var user = await _userManager.GetUserAsync(User);
_messageLikeService.LikeMessage(messageId, user.Id);
return(ApiResult.Success(true));
}
public async Task <ApiResult> UnlikeTweet(string tweetId)
{
try
{
var userId = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var result = await _likeService.RemoveLike(userId, tweetId);
return(result ? ApiResult.Success("Success") : ApiResult.BadRequest("Something went wrong"));
}
catch (Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public ApiResult GetLikes(string tweetId)
{
try
{
var userId = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var result = _likeService.GetLikes(userId, tweetId);
return(ApiResult.Success(result));
}
catch (Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult> CreateProject([FromBody] ProjectPost projectPost)
{
if (!ModelState.IsValid)
{
return(ApiResult.BadRequest(ModelState.First(e => e.Value.Errors.Any()).Value.Errors.First().ErrorMessage));
}
var currentUser = await _userManager.GetUserAsync(User);
var project = _projectService.CreateProject(projectPost.ProjectName, projectPost.ProjectDescription, currentUser.Id);
var projectModel = _mapper.Map <Core.Models.Projects.Project>(project);
return(ApiResult.Success(projectModel));
}
public ApiResult GetUserTimeline()
{
try
{
var userId = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var tweets = _timelineService.GetUserTimeline(userId);
return(ApiResult.Success(tweets));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
public async Task <ApiResult> ModifyUserTags(int userId, [FromBody] List <Core.Models.Tags.Tag> tags)
{
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user == null)
{
return(ApiResult.BadRequest());
}
var newTags = _userService.ModifyUserTags(user, tags);
var newTagsModels = _mapper.Map <List <Core.Models.Tags.Tag> >(newTags);
return(ApiResult.Success(newTagsModels));
}
public async Task <ApiResult> ForgetUser()
{
try
{
var id = User.Claims.First(c => c.Type == ClaimTypes.Name).Value.ToString();
var result = await _userService.ForgetUser(id);
return(result ? ApiResult.Success("Account deleted") : ApiResult.NotFound("User could not be found"));
}
catch (System.Exception)
{
return(ApiResult.BadRequest("Something went wrong"));
}
}
