public async Task <IActionResult> AddRole([FromBody] Role role)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var checkRole = await _context.Roles.Where(r => r.Name.Equals(role.Name)).FirstOrDefaultAsync();
if (checkRole != null)
{
return(HttpResponseHelper.BadRequest("Role '" + checkRole.Name + "' already exists."));
}
_context.Roles.Add(role);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(CreatedAtRoute("GetRole", new { id = role.Id }, role));
}
public async Task <Result <HttpResponse> > UpdatePermission(PermissionDto permissionDto)
{
try
{
var exists = await _unitOfWork.PermissionRepository.ExistAsync(x => x.Id == permissionDto.Id);
if (!exists)
{
return(HttpResponseHelper.NewResult(HttpStatusCode.Conflict, HttpResponseHelper.NewHttpResponse(error: "The permission doesn't exist.")));
}
var permissionTypeExist = await _unitOfWork.PermissionTypeRepository.ExistAsync(x => x.Id == permissionDto.PermissionType.Id);
if (!permissionTypeExist)
{
return(HttpResponseHelper.NewResult(HttpStatusCode.Conflict, HttpResponseHelper.NewHttpResponse(error: "The permission type doesn't exist.")));
}
var permission = _mapper.Map <Permission>(permissionDto);
await _unitOfWork.PermissionRepository.UpdateAsync(permission);
await _unitOfWork.SaveAsync();
return(HttpResponseHelper.NewResult(HttpStatusCode.OK, HttpResponseHelper.NewHttpResponse("The permission was updated it", success: true)));
}
catch (Exception e)
{
return(HttpResponseHelper.NewResult(HttpStatusCode.InternalServerError, HttpResponseHelper.NewHttpResponse(error: e.Message)));
}
}
public AccountController()
{
_db = new ApplicationDbContext();
_mngr = new UserManager(_db);
_helper = new HttpResponseHelper<UserInfoVM>(this);
_errHelper = new HttpResponseHelper<HttpError>(this);
}
/// <summary>
/// 获取文本返回
/// </summary>
/// <param name="actionResult"></param>
/// <returns></returns>
protected virtual IFullHttpResponse GetTextResponse(object actionResult)
{
Dictionary <AsciiString, object> headers = HttpResponseHelper.GetDefaultHeaders("text/plain;charset=utf-8");
IFullHttpResponse result = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK, actionResult.ToString(), headers);
return(result);
}
public async Task <IActionResult> GetMatchDetailed([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var match =
await _context.Matches.Where(m => m.Id.Equals(id)).Include(m => m.Tournament).FirstOrDefaultAsync();
if (match == null)
{
return(HttpResponseHelper.NotFound($"No Match found with Id {id}."));
}
match.Actors =
await _context.MatchActors.Where(a => a.MatchId.Equals(id)).Include(a => a.Actor).ToListAsync();
IList <Guid> matchActorIds = match.Actors.AsEnumerable().Select(a => a.Id).ToList();
match.Rounds =
await
_context.MatchRounds.Where(r => matchActorIds.Contains(r.MatchActorId))
.OrderBy(r => r.RoundNumber)
.ToListAsync();
return(Ok(match));
}
private string HandleRequest(HttpRequest acceptedRequest)
{
var firstHeaderTokens = acceptedRequest.StartingLine.Split(' ');
var method = firstHeaderTokens[0];
var resourcePath = firstHeaderTokens[1];
var uriToMatch = new Uri(this.baseAddress, resourcePath);
var matched = this.dispatcher.Match(method, uriToMatch);
if (matched == null)
{
Logger.Warn("Unknown command recived: {0}", uriToMatch);
return(HttpResponseHelper.ResponseString(HttpStatusCode.NotFound, "Unknown command " + uriToMatch));
}
var commandName = matched.Data.ToString();
var commandToExecute = new Command(commandName, acceptedRequest.MessageBody);
foreach (string variableName in matched.BoundVariables.Keys)
{
commandToExecute.Parameters[variableName] = matched.BoundVariables[variableName];
}
var commandResponse = this.ProcessCommand(commandToExecute);
return(HttpResponseHelper.ResponseString(commandResponse.HttpStatusCode, commandResponse.Content));
}
public async Task <IActionResult> PutGoal([FromRoute] Guid id, [FromBody] Goal form)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var goal = await _context.Goals.Where(g => g.Id.Equals(id)).FirstOrDefaultAsync();
if (goal == null)
{
return(HttpResponseHelper.NotFound("No such Goal found."));
}
_context.Entry(goal).State = EntityState.Modified;
goal.Description = form.Description;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(goal));
}
public async Task <IActionResult> DeleteGoal([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var goal = await _context.Goals.FindAsync(id);
if (goal == null)
{
return(HttpResponseHelper.NotFound("No Goal found."));
}
goal.IsDeleted = true;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(goal));
}
public override async Task <HttpResponse> Invoke(HttpRequest request)
{
var ext = GetExtension(request.Url);
if (ext == string.Empty)
{
return(await Next?.Invoke(request));
}
if (!EnableFileTypes.Keys.Any(x => x.ToLower().Equals(ext)))
{
return(await Next?.Invoke(request));
}
var fileinfo = fileProvider.GetFileInfo(request.Url);
if (!fileinfo.Exists)
{
return(await HttpResponseHelper.CreateNotFoundResponseAsync());
}
using (var stream = fileinfo.CreateReadStream())
{
var res = new HttpResponse
{
ContentType = EnableFileTypes[ext],
};
await res.WriteBodyAsync(stream);
res.Headers.Add("Cache-Control", DefaultCacheStrategy);
return(res);
}
}
public async Task <IActionResult> GetActorGoal([FromRoute] Guid id)
{
var goal =
await
_context.ActorGoal.Where(g => g.GoalId.Equals(id))
.Where(g => g.ActorId.Equals(session.Player.Id))
.Include(g => g.Actor)
.Include(g => g.Goal)
.Include(g => g.ConcernOutcome)
.Include(g => g.RewardResourceOutcome)
.Include(g => g.Activity)
.Include(g => g.Role)
.FirstOrDefaultAsync();
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
if (goal == null)
{
return(HttpResponseHelper.NotFound("No ActorGoal found."));
}
return(Ok(goal));
}
public async Task <IActionResult> DeleteInventory([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var inventory = await _context.Inventory.FindAsync(id);
if (inventory == null)
{
return(HttpResponseHelper.NotFound("No Inventory found."));
}
_context.Inventory.Remove(inventory);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(inventory));
}
public TripController()
{
_db = new ApplicationDbContext();
_mngr = new TripManager(_db);
_helper = new HttpResponseHelper<TripVM>(this);
_errHelper = new HttpResponseHelper<HttpError>(this);
}
public async Task <IActionResult> Logout([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var playerSession = await _context.Sessions.FindAsync(id);
if (playerSession == null)
{
return(HttpResponseHelper.NotFound("No such Session found."));
}
playerSession.IsExpired = true;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(playerSession));
}
public async Task <IActionResult> DeleteReward([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var reward = await _context.Rewards.FindAsync(id);
if (reward == null)
{
return(HttpResponseHelper.NotFound("No Reward found."));
}
_context.Rewards.Remove(reward);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(reward));
}
public HttpResponseMessage GetToken(string userId)
{
ResultMsg resultMsg = null;
int id = 0;
// verify incoming parameters.
if (string.IsNullOrEmpty(userId) || (!int.TryParse(userId, out id)))
{
resultMsg = new ResultMsg();
resultMsg.StatusCode = (int)StatusCodeEnum.ParameterError;
resultMsg.Info = "参数错误";
resultMsg.Data = "";
return(HttpResponseHelper.toJson(JsonConvert.SerializeObject(resultMsg)));
}
// insert cache
Token token = (Token)HttpRuntime.Cache.Get(id.ToString());
if (HttpRuntime.Cache.Get(id.ToString()) == null)
{
token = new Token();
token.Id = id;
token.SignToken = Guid.NewGuid();
token.ExpireTime = DateTime.Now.AddDays(1);
HttpRuntime.Cache.Insert(token.Id.ToString(), token, null, token.ExpireTime, TimeSpan.Zero);
}
// return token
resultMsg = new ResultMsg();
resultMsg.StatusCode = (int)StatusCodeEnum.Success;
resultMsg.Info = "";
resultMsg.Data = token;
return(HttpResponseHelper.toJson(JsonConvert.SerializeObject(resultMsg)));
}
/// <summary>
/// 获得文件返回
/// </summary>
/// <param name="url"></param>
/// <param name="IfModifiedSince"></param>
/// <returns></returns>
protected virtual async Task <IFullHttpResponse> GetFileResponseAsync(string url, ICharSequence IfModifiedSince)
{
if (url.StartsWith("/") || url.StartsWith(@"\"))
{
url = url.Substring(1);
}
string filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory ?? throw new DotNettyException("路径为空"), HtmlPageFolderPath, url);
string extension = Path.GetExtension(filePath);
if (string.IsNullOrEmpty(extension))
{
return(HttpResponseHelper.GetHttpResponse(HttpResponseStatus.NotFound));
}
if (!File.Exists(filePath))
{
return(HttpResponseHelper.GetHttpResponse(HttpResponseStatus.NotFound));
}
(FileCacheModel fileCacheModel, bool isCache) = await GetFileBytesAsync(filePath, IfModifiedSince);
string contentType = MIMEManager.GetContentType(extension);
Dictionary <AsciiString, object> headers = HttpResponseHelper.GetDefaultHeaders(contentType);
headers.Add(HttpHeaderNames.LastModified, fileCacheModel.CacheTime);
if (isCache)
{
return(HttpResponseHelper.GetHttpResponse(HttpResponseStatus.NotModified, headers));
}
headers.Add(HttpHeaderNames.Expires, DateTime.Now.AddSeconds(CacheSecond));
headers.Add(HttpHeaderNames.CacheControl, $"max-age={CacheSecond}");
return(HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK, fileCacheModel.Body, headers));
}
public async Task <IActionResult> DeleteAchievement([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var achievement = await _context.Achievements.FindAsync(id);
if (achievement == null)
{
return(HttpResponseHelper.NotFound("No Achievement found."));
}
_context.Achievements.Remove(achievement);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(achievement));
}
public async Task <IActionResult> DisableGroup([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var group = await _context.Groups.FindAsync(id);
if (group == null)
{
return(HttpResponseHelper.NotFound("No Group found."));
}
group.IsEnabled = false;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(group));
}
public async Task <IActionResult> AddItemType([FromBody] ItemType itemType)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var type = await _context.ItemTypes.Where(t => t.Name.Equals(itemType.Name)).FirstOrDefaultAsync();
if (type != null)
{
return(HttpResponseHelper.BadRequest("ItemType '" + itemType.Name + "' already exists."));
}
_context.ItemTypes.Add(itemType);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(CreatedAtRoute("GetItemType", new { id = itemType.Id }, itemType));
}
public async Task <IActionResult> UpdateMatch([FromRoute] Guid id, [FromBody] Match matchForm)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var match = await _context.Matches.Where(m => m.Id.Equals(id)).FirstOrDefaultAsync();
if (match == null)
{
return(HttpResponseHelper.NotFound("No such Match found."));
}
_context.Entry(match).State = EntityState.Modified;
match.Title = matchForm.Title;
match.ExpirationDate = matchForm.ExpirationDate;
match.IsFinished = matchForm.IsFinished;
match.IsDeleted = matchForm.IsDeleted;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(match));
}
public EstablishmentsController(ILogger <EstablishmentsController> logger, EstablishmentService establishmentService, ControllerMessages responseMessages)
{
this.logger = logger;
this.establishmentService = establishmentService;
this.httpResponseHelper = new HttpResponseHelper();
this.responseMessages = responseMessages;
}
/// <summary>
/// 处理Action过滤器
/// </summary>
/// <param name="request"></param>
/// <param name="globalFilters"></param>
/// <returns></returns>
public async Task <IFullHttpResponse> HandlerActionBeforeFilterAsync(IFullHttpRequest request, params IFilter[] globalFilters)
{
IFullHttpResponse response = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK);
List <Attribute> attributes = Action.GetCustomAttributes().ToList();
List <IActionBeforeFilter> filters = attributes.OfType <IActionBeforeFilter>().ToList();
if (globalFilters != null && globalFilters.Length > 0)
{
filters.AddRange(globalFilters.OfType <IActionBeforeFilter>());
}
foreach (IActionBeforeFilter filter in filters)
{
filter.HandlerFilter(BaseController, this, request, ref response);
if (response.Status.Code != HttpResponseStatus.OK.Code)
{
return(response);
}
}
List <IActionBeforeAsyncFilter> asyncFilters = attributes.OfType <IActionBeforeAsyncFilter>().ToList();
if (globalFilters != null && globalFilters.Length > 0)
{
asyncFilters.AddRange(globalFilters.OfType <IActionBeforeAsyncFilter>());
}
foreach (IActionBeforeAsyncFilter filter in asyncFilters)
{
await filter.HandlerFilterAsync(BaseController, this, request, ref response);
if (response.Status.Code != HttpResponseStatus.OK.Code)
{
return(response);
}
}
return(response);
}
private async Task <IEnumerable <LookupItem> > queryElastic(string accessor, int pageSize, int page, QueryType type, string query, bool caseSensitive = false)
{
var queryJson = ElasticHelper.GetQueryJson(pageSize, page, type, query);
using (var client = new HttpClient(new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
}))
{
client.BaseAddress = _elasticUrl;
var content = new StringContent(queryJson, Encoding.UTF8, "application/json");
var r = await client.PostAsync($"{accessor}/_search", content);
if (r.StatusCode != HttpStatusCode.OK)
{
throw new Exception($"Querying Elastic on {accessor}/_count with {queryJson} did not return OK - {r.StatusCode.ToString()} - {r.Content.ToString()}");
}
var resp = await HttpResponseHelper.ReadResponseContent <ElasticSearchResponse <ElasticLookupItem> >(r.Content);
List <LookupItem> ret = new List <LookupItem>();
if (resp.hits != null)
{
resp.hits.hits.ToList().ForEach(x =>
{
ret.Add(new LookupItem(x._id.ToString(), x._source.doc.Label.ToString()));
});
}
return(ret.Count > 0 ? ret : null);
}
}
public override void OnActionExecuting(HttpActionContext actionContext)
{
if (!actionContext.ModelState.IsValid)
{
HttpResponseHelper.CreateBadRequestResponse(actionContext, actionContext.ModelState);
}
}
public IFullHttpResponse HandlerException(IByteBufferHolder byteBufferHolder, Exception exception)
{
ConsoleHelper.ServerWriteError(exception);
ResultModel resultModel = ResultModel.Fail("服务器错误，请联系后端工程师");
return(HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK, resultModel.ToJson()));
}
public LocationController()
{
_db = new ApplicationDbContext();
_mngr = new LocationManager(_db);
_helper = new HttpResponseHelper<LocationVM>(this);
_errHelper = new HttpResponseHelper<HttpError>(this);
}
public StoryController()
{
_db = new ApplicationDbContext();
_mngr = new StoryManager(_db);
_helper = new HttpResponseHelper<StoryVM>(this);
_errHelper = new HttpResponseHelper<HttpError>(this);
}
public async Task <IActionResult> Unalliance([FromRoute] Guid allianceId)
{
if (session?.Player == null)
{
return(HttpResponseHelper.BadRequest("Error with your session."));
}
var actor = await _context.Actors.FindAsync(allianceId);
if (actor == null)
{
return(HttpResponseHelper.NotFound("No such Actor found."));
}
var alliance =
await _context.Alliances.Where(Alliance.IsAlliance(allianceId, session.Player.Id)).FirstOrDefaultAsync();
if (alliance == null)
{
return(HttpResponseHelper.BadRequest("Alliance is not in list."));
}
_context.Alliances.Remove(alliance);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok("Alliance Removed from the list."));
}
public async Task <ICollection <Hit> > GetImagesAsync()
{
var composer = new HttpImageRequestComposer();
if (!composer.IsCorrectRequest)
{
await HttpRequestComposer.DisplayAlertAsync();
return(null);
}
var response = await _httpClient.GetAsync(composer.UrlRequest);
if (!response.IsSuccessStatusCode)
{
var list = UnitOfWork.Hits.GetItems();
if (list is not null)
{
return(list);
}
HttpResponseHelper.DisplayNotSuccessfulStatusCodeAlert(response);
return(null);
}
var content = await response.Content.ReadAsStringAsync();
var hits = JsonSerializer.Deserialize <GalleryResponse>(content)?.Hits;
UnitOfWork.Hits.SaveItems(hits);
return(hits);
}
public SongController()
{
_db = new MusicPortalDbContext();
_mngr = new SongManager(_db);
_helper = new HttpResponseHelper<SongVM>(this);
_heartpler = new HttpResponseHelper<HeartedSongVM>(this);
}
/// <summary>
/// 获取Json返回
/// </summary>
/// <param name="actionResult"></param>
/// <returns></returns>
protected virtual IFullHttpResponse GetJsonResponse(object actionResult)
{
Dictionary <AsciiString, object> headers = HttpResponseHelper.GetDefaultHeaders("application/json;charset=utf-8");
IFullHttpResponse result = HttpResponseHelper.GetHttpResponse(HttpResponseStatus.OK, actionResult.ToJson(), headers);
return(result);
}
public async Task <IActionResult> GetGoalDetailed([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var goal = await _context.Goals.FindAsync(id);
if (goal == null)
{
return(HttpResponseHelper.NotFound("No Goal found."));
}
goal.Concern = await _context.ConcernMatrix.FindAsync(goal.ConcernId);
goal.RewardResource = await _context.RewardResourceMatrix.FindAsync(goal.RewardResourceId);
goal.Feedback = await _context.GoalFeedback.FindAsync(goal.FeedbackId);
goal.Roles = await _context.Roles.Where(r => r.GoalId.Equals(goal.Id)).ToListAsync();
IList <Guid> activitiesIDs = goal.Roles.AsEnumerable().Select(r => r.ActivityId).ToList();
goal.Activities =
await _context.Activities.Where(a => activitiesIDs.Contains(a.Id)).OrderBy(a => a.Name).ToListAsync();
goal.Rewards = await _context.Rewards.Where(r => r.GoalId.Equals(goal.Id)).ToListAsync();
goal.Targets = await _context.Targets.Where(t => t.GoalId.Equals(goal.Id)).ToListAsync();
goal.Actions = await _context.Actions.Where(a => a.GoalId.Equals(goal.Id)).ToListAsync();
return(Ok(goal));
}
public async Task <IActionResult> GetMatchRounds([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var match = await _context.Matches.Where(m => m.Id.Equals(id)).Include(m => m.Actors).FirstOrDefaultAsync();
if (match == null)
{
return(HttpResponseHelper.NotFound("No such Match found."));
}
IList <Guid> matchActors = match.Actors.AsEnumerable().Select(a => a.Id).ToList();
IList <MatchRound> matchRounds =
await
_context.MatchRounds.Where(r => matchActors.Contains(r.MatchActorId))
.OrderBy(r => r.RoundNumber)
.ToListAsync();
IList <MatchRoundResponse> matchRoundResponse = new List <MatchRoundResponse>();
foreach (var round in matchRounds)
{
var pushRound = false;
var mRound = matchRoundResponse.FirstOrDefault(r => r.RoundNumber.Equals(round.RoundNumber));
if (mRound == null)
{
mRound = new MatchRoundResponse
{
RoundNumber = round.RoundNumber,
Actors = new List <MatchRoundActor>()
};
pushRound = true;
}
var actor = match.Actors.FirstOrDefault(a => a.Id.Equals(round.MatchActorId));
if (actor != null)
{
var matchRoundActor = new MatchRoundActor
{
ActorId = actor.ActorId,
Score = round.Score,
DateScore = round.DateScore
};
mRound.Actors.Add(matchRoundActor);
}
if (pushRound)
{
matchRoundResponse.Add(mRound);
}
}
return(Ok(matchRoundResponse));
}
public async Task <IActionResult> CreateGoal([FromBody] Goal goal)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
if (goal.ConcernId != Guid.Empty)
{
var concerntest = await _context.ConcernMatrix.FindAsync(goal.ConcernId);
if (concerntest == null)
{
return(HttpResponseHelper.NotFound("No Concern found for the passed ID"));
}
}
else if (goal.Concern == null)
{
return(HttpResponseHelper.NotFound("No Concern found"));
}
if (goal.RewardResourceId != Guid.Empty)
{
var rrtest = await _context.RewardResourceMatrix.FindAsync(goal.RewardResourceId);
if (rrtest == null)
{
return(HttpResponseHelper.NotFound("No RewardResource found for the passed ID"));
}
}
else if (goal.RewardResource == null)
{
return(HttpResponseHelper.NotFound("No RewardResource found"));
}
if (goal.FeedbackId != Guid.Empty)
{
var fbtest = await _context.GoalFeedback.FindAsync(goal.FeedbackId);
if (fbtest == null)
{
return(HttpResponseHelper.NotFound("No GoalFeedback found for the passed ID"));
}
}
else if (goal.Feedback == null)
{
return(HttpResponseHelper.NotFound("No GoalFeedback found"));
}
_context.Goals.Add(goal);
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(CreatedAtRoute("GetGoalDetailed", new { id = goal.Id }, goal));
}
public async Task <IActionResult> FinishMatch([FromRoute] Guid id)
{
if (!ModelState.IsValid)
{
return(HttpResponseHelper.BadRequest(ModelState));
}
var match = await _context.Matches.FindAsync(id);
if (match == null)
{
return(HttpResponseHelper.NotFound("No Match found."));
}
match.IsFinished = true;
var error = await SaveChangesAsync();
if (error != null)
{
return(error);
}
return(Ok(match));
}
public AccountController(ApplicationUserManager userManager,
ISecureDataFormat<AuthenticationTicket> accessTokenFormat)
{
UserManager = userManager;
AccessTokenFormat = accessTokenFormat;
_db = new ApplicationDbContext();
_mngr = new UserManager(_db);
_helper = new HttpResponseHelper<UserInfoVM>(this);
_errHelper = new HttpResponseHelper<HttpError>(this);
}
public HttpResponseMessage GetPlaylistFullFromUser()
{
HttpResponseMessage responseMsg;
HttpResponseHelper<PlaylistVM> _helper = new HttpResponseHelper<PlaylistVM>(this);
try
{
string userId = Microsoft.AspNet.Identity.IdentityExtensions.GetUserId(RequestContext.Principal.Identity);
var playlists = _mngr.getPlaylistsFull(userId);
responseMsg = _helper.CreateCustomResponseMsg(playlists.ToList(), HttpStatusCode.OK);
}
catch (Exception e)
{
responseMsg = _helper.CreateErrorResponseMsg(new HttpError(e.Message), HttpStatusCode.InternalServerError);
}
return responseMsg;
}
public UserController() {
_mngr = new UserManager();
_helper = new HttpResponseHelper<UserVM>(this);
_songHelper = new HttpResponseHelper<SongVM>(this);
}
