/// <summary>
/// Lambda to insert character to character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
if (pRequest == null)
{
return(HttpHelper.HandleError("Request appears to be null", 500));
}
//For these operations, we should have the CognitoInfo user available to us
//Authorized Users only for Deleting Raids
using (opendkpContext vDatabase = new opendkpContext())
{
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]);
if (pRequest.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
return(HandleInsert(pRequest, pContext, vCognitoUser, vDatabase));
}
else if (pRequest.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase))
{
return(HandleUpdateAsync(pRequest, pContext, vCognitoUser, vDatabase));
}
}
return(HttpHelper.HandleError("Only Methods PUT,POST are supported by this lamdba", 500));
}
/// <summary>
/// Set the cache value for a particular cache
/// </summary>
/// <param name="pContext">The database context in which to set the cache in</param>
/// <param name="pCacheName">The name of the cache you are storing, case-insensitive</param>
/// <param name="pCacheValue">The value to be stored for this cache</param>
/// <param name="pCacheExpires">The time the cache should expire</param>
public static void SetCache(opendkpContext pContext, string pCacheName, string pCacheValue, string pClientId, DateTime?pCacheExpires = null)
{
if (pCacheExpires == null)
{
pCacheExpires = DateTime.Now.AddHours(12);
}
try
{
Cache vCachedSummary = pContext.Cache.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.CacheName.Equals(pCacheName, StringComparison.InvariantCultureIgnoreCase));
if (vCachedSummary == null)
{
vCachedSummary = new Cache {
CacheName = pCacheName,
ClientId = pClientId
};
pContext.Add <Cache>(vCachedSummary);
}
vCachedSummary.CacheUpdated = DateTime.Now;
vCachedSummary.CacheExpires = DateTime.Now.AddHours(12);
vCachedSummary.CacheValue = pCacheValue;
pContext.SaveChanges();
}
catch (Exception vException)
{
Console.WriteLine("Error Cacheing: " + vException);
}
}
/// <summary>
/// Lambda to fetch character by name from character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, used to pull parameter from url</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[GetAdjustmentsById] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
int vId = int.Parse(pRequest.PathParameters["id"]);
using (opendkpContext vDatabase = new opendkpContext())
{
var vResult = vDatabase.Adjustments
.Include("IdCharacterNavigation")
.First(x => x.ClientId.Equals(vClientId) && x.IdAdjustment == vId);
var vAdjustment = new AdjustmentModel(vResult);
vResponse = HttpHelper.HandleResponse(vAdjustment, 200, true);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError(string.Format("[GetAdjustmentsById] {0}", vException.Message), 500);
}
return(vResponse);
}
/// <summary>
/// Lambda to fetch character by name from character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, used to pull parameter from url</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[GetClient] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
string vClient = pRequest.PathParameters["client"];
using (opendkpContext vDatabase = new opendkpContext())
{
var vResult = vDatabase.Clients.First(x => x.Subdomain.Equals(vClient.Trim().ToLower()));
vResponse = HttpHelper.HandleResponse(vResult, 200);
}
}
else
{
using (opendkpContext vDatabase = new opendkpContext())
{
var vResult = vDatabase.Clients.ToList();
vResponse = HttpHelper.HandleResponse(vResult, 200);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError(string.Format("[GetClient] {0}", vException.Message), 500);
}
return(vResponse);
}
/// <summary>
/// Creates an item into the db if needed (not found already)
/// </summary>
/// <param name="pDBContext">The database context in which to look or create the item in</param>
/// <param name="pItem">The item to create or lookup, checks for its Id first otherwise by name</param>
/// <returns></returns>
public static Items CreateItemIfNeeded(opendkpContext pDBContext, Items pItem)
{
Items vFoundItem = pDBContext.Items.FirstOrDefault <Items>(x => x.IdItem == pItem.IdItem);
//If we don't find the item by it's ID
if (vFoundItem == null)
{
vFoundItem = pDBContext.Items
.FirstOrDefault <Items>(x => x.Name.Trim().Equals(pItem.Name.Trim(), StringComparison.InvariantCultureIgnoreCase));
//If we don't find the item by it's name
if (vFoundItem == null)
{
var vNewItem = new Items
{
Name = pItem.Name
};
pDBContext.Add(vNewItem);
pDBContext.SaveChanges();
vFoundItem = vNewItem;
}
}
return(vFoundItem);
}
/// <summary>
/// Inserts the raid items into the database associated with the raid passed in
/// </summary>
/// <param name="pDBContext">The database context to insert items to</param>
/// <param name="pModel">The raid model containing the items</param>
/// <param name="pCharacterModels">A pre-populated character list so we dont have to look them all up on the fly</param>
public static void InsertRaidItems(opendkpContext pDBContext, string pClientId, dynamic pModel, Dictionary <string, Characters> pCharacterModels)
{
//Lets insert the items from this raid
foreach (var vItem in pModel.Items)
{
string vCharName = vItem.CharacterName;
Items vNewItem;
if (vItem.ItemID != null)
{
vNewItem = new Items()
{
IdItem = vItem.ItemID, Name = vItem.ItemName
}
}
;
else
{
vNewItem = new Items()
{
IdItem = -1, Name = vItem.ItemName
}
};
vNewItem = ItemHelper.CreateItemIfNeeded(pDBContext, vNewItem);
ItemsXCharacters vTransaction = new ItemsXCharacters()
{
Dkp = vItem.DkpValue,
CharacterId = pCharacterModels[vCharName.ToLower()].IdCharacter,
ItemId = vNewItem.IdItem,
RaidId = pModel.IdRaid,
ClientId = pClientId
};
pDBContext.Add(vTransaction);
}
}
/// <summary>
/// Gets All of the CharacterModels associated to the raid via attendance via Raid.Ticks
/// </summary>
/// <param name="pDBContext">The database context to retrieve the character models from</param>
/// <param name="pModel">The raid model containing Ticks and Attendees</param>
/// <returns></returns>
public static Dictionary <string, Characters> GetCharacterModels(opendkpContext pDBContext, string pClientId, dynamic pModel)
{
var vReturnModel = new Dictionary <string, Characters>();
foreach (var vItem in pModel.Items)
{
string vCharacterName = vItem.CharacterName;
vItem.CharacterName = vCharacterName = vCharacterName.Split(' ')[0];
if (!vReturnModel.ContainsKey(vCharacterName.ToLower()))
{
vReturnModel.Add(vCharacterName.ToLower(),
CharacterHelper.CreateCharacterIfNeeded(pDBContext, pClientId, vCharacterName));
}
}
foreach (var vTick in pModel.Ticks)
{
string[] vAttendeeArray = vTick.Attendees.ToObject <string[]>();
for (int i = 0; i < vAttendeeArray.Length; i++)
{
string vAttendee = vAttendeeArray[i].Split(' ')[0];
vTick.Attendees[i] = vAttendee.Trim();
if (!vReturnModel.ContainsKey(vAttendee.ToLower()))
{
vReturnModel.Add(vAttendee.ToLower(),
CharacterHelper.CreateCharacterIfNeeded(pDBContext, pClientId, vAttendee));
}
}
}
return(vReturnModel);
}
/// <summary>
/// Creates an individual tick
/// </summary>
/// <param name="pDBContext">The database context to store the tick</param>
/// <param name="pRaidId">The raid id the tick should be associated with</param>
/// <param name="pModel">The raid model the tick is associated with</param>
/// <param name="pCharacterModels">Prepopulated character models</param>
public static void CreateTick(opendkpContext pDBContext, string pClientId, int pRaidId, dynamic pModel, Dictionary <string, Characters> pCharacterModels)
{
Ticks vTick = new Ticks()
{
Description = pModel.Description,
Value = pModel.Value,
RaidId = pRaidId,
ClientId = pClientId
};
//Make sure we don't have duplicate attendees for each tick
//client should handle this but we'll verify here
string[] vAttendeeArray = pModel.Attendees.ToObject <string[]>();
vAttendeeArray = vAttendeeArray.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
//Add Attendees to Tick
foreach (string vAttendee in vAttendeeArray)
{
pDBContext.Add(
new TicksXCharacters()
{
IdCharacterNavigation = pCharacterModels[vAttendee.ToLower()],
IdTickNavigation = vTick,
ClientId = pClientId
});
}
}
/// <summary>
/// As the name suggests, creates a character if they are needed. Need is determined by whether or not they already exist in the database
/// </summary>
/// <param name="pDBContext">The database context to search for the character</param>
/// <param name="pCharacterName">The character name to search for, case-insensitive</param>
/// <returns></returns>
public static Characters CreateCharacterIfNeeded(opendkpContext pDBContext, string pClientId, string pCharacterName)
{
Characters vCharacterModel = pDBContext.Characters
.FirstOrDefault(x => x.Name.Equals(pCharacterName, StringComparison.InvariantCultureIgnoreCase));
//If the character doesn't exist, we need to create a blank one first
if (vCharacterModel == null)
{
vCharacterModel = new Characters
{
Name = char.ToUpper(pCharacterName[0]) + pCharacterName.Substring(1),
Class = "UNKNOWN",
Race = "UNKNOWN",
Active = 1,
Rank = "Inactive",
Level = 1,
Gender = "Male",
Guild = "Original Gangster Club",
ClientId = pClientId
};
pDBContext.Add(vCharacterModel);
pDBContext.SaveChanges();
}
return(vCharacterModel);
}
/// <summary>
/// Fetches a character by their name
/// </summary>
/// <param name="pDBContext">The database context in which to search for the character</param>
/// <param name="pCharacterName">The character name, case-insensitive</param>
/// <returns></returns>
public static Characters GetCharacterByName(opendkpContext pDBContext, string pClientId, string pCharacterName)
{
Characters vCharacterModel = pDBContext.Characters
.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Name.Equals(pCharacterName, StringComparison.InvariantCultureIgnoreCase));
return(vCharacterModel);
}
/// <summary>
/// Lambda to fetch character by name from character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, used to pull parameter from url</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[GetCharacter] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
string vCharacterName = pRequest.PathParameters["character"];
using (opendkpContext vDatabase = new opendkpContext())
{
var vResult = vDatabase.Characters.First(x => x.ClientId.Equals(vClientId) &&
x.Name.Equals(vCharacterName, StringComparison.InvariantCultureIgnoreCase));
vResult.SummaryModel = CacheManager.GetPlayerSummary(vDatabase, vCharacterName, vClientId);
vResponse = HttpHelper.HandleResponse(vResult, 200);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError(string.Format("[GetCharacter] {0}", vException.Message), 500);
}
return(vResponse);
}
/// <summary>
/// This function is designed to Compare the IAM Role associated with the UserGroup to the ClientID passed in
/// If the Roles don't match, we don't allow the request to come through
/// </summary>
/// <param name="vDatabase">dbcontext</param>
/// <param name="pArnString">The string passed in by the API Gateway stating who the user is</param>
/// <param name="pClientId">The client id the user is requesting to update for</param>
/// <returns></returns>
public static bool IsAuthorizedAdmin(opendkpContext vDatabase, APIGatewayProxyRequest pRequest)
{
//The Context Contains the Identity & Request contains the header with the client id
//string pArnString, string pClientId
try
{
string[] vArnItems = pRequest.RequestContext.Identity.UserArn.Split('/');
string vAssumedRole = string.Empty;
string vClientId = pRequest.Headers["clientid"];
if (vArnItems.Length > 1)
{
vAssumedRole = vArnItems[1];
}
if (!string.IsNullOrWhiteSpace(vAssumedRole))
{
var vClientModel = vDatabase.Clients.FirstOrDefault(x => x.ClientId.Equals(vClientId, StringComparison.InvariantCultureIgnoreCase));
if (vClientModel != null)
{
if (vClientModel.AssumedRole.Equals(vAssumedRole, StringComparison.InvariantCultureIgnoreCase))
{
return(true);
}
}
}
}
catch
{
Console.WriteLine("IsAuthorizedAdmin exception encountered");
}
return(false);
}
/// <summary>
/// TODO
/// </summary>
/// <param name="pInput">Incoming API Gateway request object, used to pull parameter from url</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public void FunctionHandler(string pInput, ILambdaContext pContext)
{
try
{
using (opendkpContext vDatabase = new opendkpContext())
{
var vChanges = new Dictionary <string, string>();
var vCharacters = vDatabase.Characters.Include("TicksXCharacters.IdTickNavigation.Raid");
foreach (Characters vCharacter in vCharacters)
{
var vTickCount = vCharacter.TicksXCharacters.Where(x => DateTime.Compare(x.IdTickNavigation.Raid.Timestamp.Date,
DateTime.Now.AddDays(-60).Date) >= 0).Count();
if (vTickCount > 0 && vCharacter.Active == 0)
{
vCharacter.Active = 1;
Console.WriteLine(string.Format("{0} Marked ACTIVE, Total Ticks = {1}", vCharacter.Name, vTickCount));
vChanges.Add(vCharacter.Name, "Marked Active, Total Ticks = " + vTickCount);
}
if (vTickCount <= 0 && vCharacter.Active == 1)
{
vCharacter.Active = 0;
Console.WriteLine(string.Format("{0} Marked INACTIVE, Total Ticks = {1}", vCharacter.Name, vTickCount));
vChanges.Add(vCharacter.Name, "Marked Inactive, Total Ticks = " + vTickCount);
}
}
vDatabase.SaveChanges();
}
}
catch (Exception vException)
{
Console.WriteLine(vException);
}
}
/// <summary>
/// Lambda to insert character to character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
if (pRequest == null)
{
return(HttpHelper.HandleError("Request appears to be null", 500));
}
using (opendkpContext vDatabase = new opendkpContext())
{
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
if (pRequest.HttpMethod.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
return(HandleInsert(pRequest, pContext, vCognitoUser, vDatabase, vClientId));
}
else if (pRequest.HttpMethod.Equals("POST", StringComparison.InvariantCultureIgnoreCase))
{
return(HandleUpdate(pRequest, pContext, vCognitoUser, vDatabase, vClientId));
}
}
return(HttpHelper.HandleError("Only Methods PUT,POST are supported by this lamdba", 500));
}
private APIGatewayProxyResponse UpdateCharacterAssignRequest(opendkpContext pDatabase, string pClientId, UserRequests pUserRequest, CognitoUser pCognitoUser)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
if (!string.IsNullOrWhiteSpace(pUserRequest.Requestor) && !string.IsNullOrWhiteSpace(pUserRequest.RequestDetails))
{
if (pUserRequest.RequestStatus == UserRequests.STATUS_APPROVED)
{
dynamic vCharacterId = JsonConvert.DeserializeObject(pUserRequest.RequestDetails);
int vId = vCharacterId.characterId;
//I need to associate the character
//If character associate is successful, I need to update pending request to completed
using (var dbContextTransaction = pDatabase.Database.BeginTransaction())
{
UserXCharacter vAssociation = new UserXCharacter();
vAssociation.User = pUserRequest.Requestor;
vAssociation.IdCharacter = vId;
vAssociation.ApprovedBy = pCognitoUser.Username;
vAssociation.ClientId = pClientId;
pDatabase.Add(vAssociation);
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_APPROVED;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
dbContextTransaction.Commit();
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
else if (pUserRequest.RequestStatus == UserRequests.STATUS_DENIED)
{
UserRequests vRequest = pDatabase.UserRequests.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Id == pUserRequest.Id);
if (vRequest == null)
{
return(HttpHelper.HandleError("[UserRequestsLambda] Couldn't find the Request in DB to update...", 500));
}
vRequest.RequestApprover = pCognitoUser.Username;
vRequest.ReviewedTimestamp = DateTime.Now;
vRequest.RequestStatus = UserRequests.STATUS_DENIED;
vRequest.RequestDetails = pUserRequest.RequestDetails;
vRequest.ClientId = pClientId;
pDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(vRequest, 200, true);
}
}
return(vResponse);
}
/// <summary>
/// Lambda to insert character to character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[DeleteAdjustment] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
int vId = int.Parse(pRequest.PathParameters["id"]);
using (opendkpContext vDatabase = new opendkpContext())
{
//Authorized Users only for Deleting Adjustments
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
var vResult = vDatabase.Adjustments
.FirstOrDefault(x => x.ClientId.Equals(vClientId) && x.IdAdjustment == vId);
if (vResult != null)
{
vDatabase.Adjustments.Remove(vResult);
vDatabase.SaveChanges();
//Audit
AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_ADJUST_DELETE);
//Update Caches
int vStatus = CacheManager.UpdateSummaryCacheAsync(vClientId).GetAwaiter().GetResult();
Console.WriteLine("StatusCode for CacheUpdate=" + vStatus);
vResponse = HttpHelper.HandleResponse(vResult, 200, true);
}
else
{
vResponse = HttpHelper.HandleError("[DeleteAdjustment] Adjustment doesnt exist in DB", 500);
}
}
}
}
catch
{
vResponse = HttpHelper.HandleError("[DeleteAdjustment] Issue with DB or Query", 500);
}
return(vResponse);
}
/// <summary>
/// Lambda to fetch all characters from the character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, not used currently</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[CognitoAPIs] Unknown Error in backend", 500);
try
{
string pUserPool = string.Empty;
//The request should be from an authorized user, if yes then also grab the UserPool for the associated client
using (opendkpContext vDatabase = new opendkpContext())
{
//Authorized Users only for Audit information
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
//No validation on header because it's pre-performed above in the CognitoHelper
pUserPool = vDatabase.Clients.
FirstOrDefault(x => x.ClientId.Equals(pRequest.Headers["clientid"],
StringComparison.InvariantCultureIgnoreCase)).UserPool;
}
if (pRequest.HttpMethod == "GET")
{
Task <object> vTask = GetAllUsersAsync(pUserPool);
vResponse = HttpHelper.HandleResponse(vTask.Result, 200);
}
if (pRequest.HttpMethod == "POST")
{
dynamic vModel = JsonConvert.DeserializeObject(pRequest.Body);
string vAction = vModel.Action;
string vData = vModel.Data;
if (vAction.Equals("add-admin"))
{
Task <string> vTask = AddDkpAdminAsync(vData, pUserPool);
vResponse = HttpHelper.HandleResponse(vTask.Result, 200);
}
else if (vAction.Equals("remove-admin"))
{
Task <string> vTask = RemoveDkpAdminAsync(vData, pUserPool);
vResponse = HttpHelper.HandleResponse(vTask.Result, 200);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError("[CognitoAPIs] " + vException.Message, 500);
}
return(vResponse);
}
public void InjectRequestDetails(opendkpContext pDatabase, string pClientId, UserRequests pRequest)
{
JsonSerializerSettings vSettings = new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
if (pRequest.RequestType == UserRequests.TYPE_CHARACTER_ASSIGN)
{
dynamic vModel = JsonConvert.DeserializeObject(pRequest.RequestDetails);
int vId = vModel.characterId;
Characters vCharacter = pDatabase.Characters.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.IdCharacter == vId);
vModel.character = JsonConvert.SerializeObject(vCharacter, vSettings);
pRequest.RequestDetails = JsonConvert.SerializeObject(vModel, vSettings);
}
if (pRequest.RequestType == UserRequests.TYPE_RAIDTICK)
{
dynamic vModel = JsonConvert.DeserializeObject(pRequest.RequestDetails);
string vCharacterName = vModel.characterName;
int vTickId = vModel.tickId;
string vReason = vModel.reason;
var vFound = pDatabase.TicksXCharacters.
Include("IdTickNavigation.Raid").
FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.IdTick == vTickId);
object vCustomModel = null;
if (vFound != null)
{
vCustomModel = new
{
Character = vCharacterName,
Raid = vFound.IdTickNavigation.Raid.Name,
vFound.IdTickNavigation.Raid.Timestamp,
Tick = vFound.IdTickNavigation.Description,
DkpValue = vFound.IdTickNavigation.Value
};
}
else
{
vCustomModel = new
{
Character = vCharacterName,
Raid = "UNKNOWN",
Timestamp = DateTime.Now,
Tick = "UNKNOWN",
DkpValue = 0
};
}
vModel.raid = JsonConvert.SerializeObject(vCustomModel, vSettings);
pRequest.RequestDetails = JsonConvert.SerializeObject(vModel, vSettings);
}
}
/// <summary>
/// Lambda to fetch all characters from the character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, not used currently</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[AuditLambda] Unknown Error in backend", 500);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
try
{
int vId = -1;
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
vId = int.Parse(pRequest.PathParameters["id"]);
}
using (opendkpContext vDatabase = new opendkpContext())
{
//Authorized Users only for Audit information
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
if (pRequest.HttpMethod.Equals("GET", StringComparison.InvariantCultureIgnoreCase))
{
List <Audit> vResult;
if (vId > -1)
{
vResult = vDatabase.Audit.Where(x => x.ClientId.Equals(vClientId) && x.Id == vId).ToList();
}
else
{
//We don't want to transmit a ton of data for fetching all audits
vResult = vDatabase.Audit.Where(x => x.ClientId.Equals(vClientId)).ToList();
foreach (Audit vItem in vResult)
{
vItem.NewValue = string.Empty;
vItem.OldValue = string.Empty;
}
}
vResponse = HttpHelper.HandleResponse(vResult, 200, true);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError("[AuditLambda] " + vException.Message, 500);
}
return(vResponse);
}
private APIGatewayProxyResponse GetAllRequests(opendkpContext pDatabase, string pClientId)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
var vResults = pDatabase.UserRequests.Where(x => x.ClientId.Equals(pClientId)).ToList();
foreach (UserRequests vRequest in vResults)
{
InjectRequestDetails(pDatabase, pClientId, vRequest);
}
vResponse = HttpHelper.HandleResponse(vResults, 200, true);
return(vResponse);
}
/// <summary>
/// Lambda to insert character to character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[DeleteCharacter] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
string vCharacterName = pRequest.PathParameters["character"];
using (opendkpContext vDatabase = new opendkpContext())
{
//Authorized Users only for Deleting Characters
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]);
var vResult = vDatabase.
Characters.
FirstOrDefault(x => x.ClientId.Equals(vClientId) &&
x.Name.Equals(vCharacterName, StringComparison.InvariantCultureIgnoreCase));
if (vResult != null)
{
vDatabase.Characters.Remove(vResult);
vDatabase.SaveChanges();
AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_CHAR_DELETE);
vResponse = HttpHelper.HandleResponse(vResult, 200);
}
else
{
vResponse = HttpHelper.HandleError("[DeleteCharacter] Character doesn't exist in the DB", 500);
}
}
}
}
catch
{
vResponse = HttpHelper.HandleError("[DeleteCharacter] Issue with DB or Query", 500);
}
return(vResponse);
}
/// <summary>
/// Deletes a raid based off the raid id
/// </summary>
/// <param name="pDBContext">The database context in which to delete the raid</param>
/// <param name="pRaidId">The raid id to delete</param>
/// <returns></returns>
public static Raids DeleteRaid(opendkpContext pDBContext, int pRaidId, string pClientId)
{
Raids vResult;
vResult = pDBContext.Raids
.FirstOrDefault <Raids>(x => x.ClientId.Equals(pClientId) && x.IdRaid == pRaidId);
if (vResult != null)
{
pDBContext.Raids.Remove(vResult);
}
return(vResult);
}
/// <summary>
/// Lambda to fetch all characters from the character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, not used currently</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers != null && pRequest.Headers.Count > 0 && pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[GetAllCharacters] Unknown Error in backend", 500);
try
{
using (opendkpContext vDatabase = new opendkpContext())
{
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
string vAccountName = pRequest.PathParameters["account"].Trim();
var vTmpList = vDatabase.UserXCharacter
.Where(x => x.ClientId.Equals(vClientId) && x.User.Trim().Equals(vAccountName, StringComparison.InvariantCultureIgnoreCase)).ToList();
var vResult = new List <Characters>();
var vList = new List <int>();
foreach (var vCharacter in vTmpList)
{
vList.Add(vCharacter.IdCharacter);
}
vResult = vDatabase.Characters.Where(x => x.ClientId.Equals(vClientId) && vList.Contains(x.IdCharacter)).ToList();
vResponse = HttpHelper.HandleResponse(vResult, 200, true);
}
else
{
object vResult = null;
if (pRequest.QueryStringParameters != null && pRequest.QueryStringParameters.Count > 0 &&
pRequest.QueryStringParameters.ContainsKey("IncludeInactives"))
{
vResult = vDatabase.Characters.Where(x => x.ClientId.Equals(vClientId)).ToList <Characters>();
}
else
{
vResult = vDatabase.Characters.Where(x => x.ClientId.Equals(vClientId) &&
x.Active == 1).ToList <Characters>();
}
vResponse = HttpHelper.HandleResponse(vResult, 200);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError("[GetAllCharacters] " + vException.Message, 500);
}
return(vResponse);
}
/// <summary>
/// A simple function that takes a string and does a ToUpper
/// </summary>
/// <param name="input"></param>
/// <param name="context"></param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[GetItemsByCharacter] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
string vCharacterName = pRequest.PathParameters["id"];
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
using (opendkpContext vDatabase = new opendkpContext())
{
var vItems = new List <object>();
var vResult = vDatabase.Characters
.Include("ItemsXCharacters.Item")
.Include("ItemsXCharacters.Raid").
First(x => x.ClientId.Equals(vClientId) && x.Name.Equals(vCharacterName, StringComparison.InvariantCultureIgnoreCase));
foreach (var vItem in vResult.ItemsXCharacters)
{
vItems.Add(new
{
ItemName = vItem.Item.Name,
ItemID = vItem.ItemId,
Raid = vItem.Raid.Name,
RaidID = vItem.RaidId,
Date = vItem.Raid.Timestamp,
DkpValue = vItem.Dkp
});
}
vResponse = HttpHelper.HandleResponse(vItems, 200, true);
}
}
}
catch (Exception vException)
{
vResponse = HttpHelper.HandleError(string.Format("[GetItemsByCharacter] {0}", vException.Message), 500);
}
return(vResponse);
}
/// <summary>
/// Fetches the cached value from the database context passed in
/// </summary>
/// <param name="pContext">The database context</param>
/// <param name="pCacheName">The name of the cahce you are retriving, case-insensitive</param>
/// <returns></returns>
public static Cache GetCache(opendkpContext pContext, string pCacheName, string pClientId)
{
Cache vReturnModel = null;
try
{
vReturnModel = pContext.Cache.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.CacheName.Equals(pCacheName, StringComparison.InvariantCultureIgnoreCase));
}
catch (Exception vException)
{
Console.WriteLine("Error Retriving Cache: " + vException);
}
return(vReturnModel);
}
private APIGatewayProxyResponse GetAccountRequests(opendkpContext pDatabase, string pAccount, string pClientId)
{
var vResponse = HttpHelper.HandleError("[UserRequestsLambda] Issue with DB or Query", 500);
var vResults = pDatabase.UserRequests.
Where(x => x.ClientId.Equals(pClientId) && x.Requestor.ToLower().Equals(pAccount.ToLower(), StringComparison.InvariantCultureIgnoreCase))
.ToList();
foreach (UserRequests vRequest in vResults)
{
InjectRequestDetails(pDatabase, pClientId, vRequest);
}
vResponse = HttpHelper.HandleResponse(vResults, 200, true);
return(vResponse);
}
/// <summary>
/// Fetches the Player Summary Cache, mostly a helper function to pull out PlayerSummaryModel
/// </summary>
/// <param name="pContext">The database to retrieve the cache from</param>
/// <param name="pCharacterName">The name of the character to pull from, case-insensitive</param>
/// <returns></returns>
public static PlayerSummaryModel GetPlayerSummary(opendkpContext pContext, string pCharacterName, string pClientId)
{
var vReturnModel = new PlayerSummaryModel();
Cache vCachedSummary = GetCache(pContext, SUMMARY, pClientId);
var vModel = JsonConvert.DeserializeObject <SummaryModel>(vCachedSummary.CacheValue);
foreach (var vItem in vModel.Models)
{
if (vItem.CharacterName.Equals(pCharacterName, StringComparison.InvariantCultureIgnoreCase))
{
return(vItem);
}
}
return(vReturnModel);
}
/// <summary>
/// Lambda to insert character to character table
/// </summary>
/// <param name="pRequest">Incoming API Gateway request object, should be a PUT or POST with a BODY</param>
/// <param name="pContext">Incoming Lambda Context object, not used currently</param>
/// <returns></returns>
public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest pRequest, ILambdaContext pContext)
{
if (pRequest.Headers.Keys.Contains("warmup"))
{
return(HttpHelper.WarmupResponse());
}
var vResponse = HttpHelper.HandleError("[DeleteRaid] Unknown Backend error", 500);
try
{
if (pRequest != null && pRequest.PathParameters != null && pRequest.PathParameters.Count > 0)
{
int vId = int.Parse(pRequest.PathParameters["id"]);
using (opendkpContext vDatabase = new opendkpContext())
{
//Authorized Users only for Deleting Raids
if (!CognitoHelper.IsDkpAdmin(pRequest) ||
!CognitoHelper.IsAuthorizedAdmin(vDatabase, pRequest))
{
return(HttpHelper.HandleError("You do not have permission to perform this action", 401));
}
var vCognitoUser = CognitoHelper.GetCognitoUser(pRequest.Headers["cognitoinfo"]);
//We need to retrieve the ClientId for multitenancy purposes
var vClientId = pRequest.Headers["clientid"];
Raids vResult = RaidHelper.DeleteRaid(vDatabase, vId, vClientId);
vDatabase.SaveChanges();
vResponse = HttpHelper.HandleResponse(vResult, 200);
//Audit
AuditHelper.InsertAudit(vDatabase, vClientId, vResult, string.Empty, vCognitoUser.Username, Audit.ACTION_RAID_DELETE);
//Update Caches
int vStatus = CacheManager.UpdateSummaryCacheAsync(vClientId).GetAwaiter().GetResult();
Console.WriteLine("SummaryCacheResponse=" + vStatus);
vStatus = CacheManager.UpdateItemCacheAsync(vClientId).GetAwaiter().GetResult();
Console.WriteLine("ItemCacheResponse=" + vStatus);
}
}
}
catch
{
vResponse = HttpHelper.HandleError("[DeleteRaid] Issue with DB or Query", 500);
}
return(vResponse);
}
/// <summary>
/// Converts a Character Name into the Character Id
/// </summary>
/// <param name="pDatabase">The database context in which to look up the character</param>
/// <param name="pCharacterName">The character name, case-insensitive</param>
/// <returns></returns>
public static int CharacterNameToId(opendkpContext pDatabase, string pClientId, string pCharacterName)
{
int vCharacterId = -1;
try
{
Characters vModel = pDatabase.Characters
.FirstOrDefault(x => x.ClientId.Equals(pClientId) && x.Name.Equals(pCharacterName.Trim(), StringComparison.InvariantCultureIgnoreCase));
vCharacterId = vModel.IdCharacter;
}
catch
{
throw new Exception(string.Format("{0} does not exist in the database", pCharacterName));
}
return(vCharacterId);
}
/// <summary>
/// Deletes a UserRequest from the Database
/// </summary>
/// <param name="pDBContext">The database in which to delete the UserREquest from</param>
/// <param name="pRequest">The UserRequest to delete</param>
/// <returns></returns>
public static bool DeleteRequest(opendkpContext pDBContext, UserRequests pRequest)
{
bool vReturn = false;
try
{
pDBContext.Remove(pRequest);
pDBContext.SaveChanges();
vReturn = true;
}
catch (Exception vException)
{
Console.WriteLine("Error Inserting AdminRequest: " + vException);
}
return(vReturn);
}
