private string RejectTag(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
if (user != null &&
(user.UserType == UserTypes.SuperUser ||
user.UserType == UserTypes.Administrator))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
string sTagGuid = _parameters["tagGuid"];
Guid tagGuid;
if (Guid.TryParse(sTagGuid, out tagGuid))
{
Tag tag = hwManager.GetTag(tagGuid);
if (tag != null)
{
if (tag.Status == TagStatus.Pending)
{
tag.Status = TagStatus.Rejected;
hwManager.Persist(tag);
return(@"{ ""Result"":""Success"" }");
}
}
}
}
}
return(@"{ ""Result"":""Failure"" }");
}
public string GetCenterRadiusCSVData(double _latitude, double _longitude, double _distance,
bool _includeCenter = false)
{
HydrantWikiManager hwm = new HydrantWikiManager();
GeoPoint point = new GeoPoint(_longitude, _latitude);
List <NearbyHydrant> hydrants = hwm.GetNearbyHydrants(point, _distance);
if (_includeCenter)
{
NearbyHydrant center = new NearbyHydrant()
{
Color = "#F51D5A",
Symbol = "cross",
DistanceInFeet = "0.0",
Position = new GeoPoint(_longitude, _latitude),
HydrantGuid = Guid.Empty,
Title = "Tag"
};
hydrants.Add(center);
}
string csv = HydrantCSVHelper.GetHydrantCSV(hydrants);
return(csv);
}
private string HandleGetMyTagsInTable(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
List <Tag> tags = hwManager.GetTagsForUser(user.Guid);
TagTableResponse response = new TagTableResponse {
Result = "Success"
};
foreach (Tag tag in tags)
{
JsonObjects.Tag jTag = new JsonObjects.Tag(tag);
response.Data.Add(jTag);
}
string json = JsonConvert.SerializeObject(response);
return(json);
}
return(null);
}
public BaseResponse HangleGetHydrantsByCenterDistance(DynamicDictionary _parameters)
{
var response = new BaseResponse {
Success = false
};
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
double latitude = Convert.ToDouble((string)_parameters["latitude"]);
double longitude = Convert.ToDouble((string)_parameters["longitude"]);
double distance = Convert.ToDouble((string)_parameters["distance"]);
HydrantWikiManager hwm = new HydrantWikiManager();
GeoPoint center = new GeoPoint(longitude, latitude);
List <Hydrant> hydrants = hwm.GetHydrants(center, distance);
List <HydrantHeader> headers = ProcessHydrants(hydrants, center);
response = new HydrantQueryResponse {
Success = true, Hydrants = headers
};
hwm.LogInfo(user.Guid, "Retrieved Hydrants by Center and Distance");
return(response);
}
else
{
LogUnauthorized(Request);
}
return(response);
}
private string HandleResetPassword(DynamicDictionary _parameters)
{
string email = Request.Headers["EmailAddress"].First();
if (email != null)
{
HydrantWikiManager hwm = new HydrantWikiManager();
User user = hwm.GetUserByEmail(UserSources.HydrantWiki, email.ToLower());
if (user != null)
{
string newPassword = RandomString.GetRandomString(10);
TGUserPassword up = TGUserPassword.GetNew(user.Guid, user.Username, newPassword);
hwm.Persist(up);
NameValueCollection nvc = new NameValueCollection
{
{ "Password", newPassword }
};
hwm.SendCannedEmail(user, CannedEmailNames.ResetPasswordEmail, nvc);
}
return("{ \"Result\":\"Success\"}");
}
return("{ \"Result\":\"Failure\"}");
}
public static Dictionary <Guid, int> GetNewHydrantsByUser(this HydrantWikiManager _manager)
{
HydrantWikiManager manager = new HydrantWikiManager();
List <Hydrant> hydrants = manager.GetHydrants();
Dictionary <Guid, User> users = manager.GetHydrantWikiUsers();
Dictionary <Guid, int> hydrantCountByUser = new Dictionary <Guid, int>();
foreach (var hydrant in hydrants)
{
Guid userGuid = hydrant.OriginalTagUserGuid;
if (users.ContainsKey(userGuid))
{
int count = 0;
if (hydrantCountByUser.ContainsKey(userGuid))
{
count = hydrantCountByUser[userGuid];
}
count++;
hydrantCountByUser[userGuid] = count;
}
}
return(hydrantCountByUser);
}
private string HandleGetStatistics(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
long siteUserCount = hwManager.GetUserCount();
long siteHydrantCount = hwManager.GetHydrantCount();
long siteTagCount = hwManager.GetTagCount();
StringBuilder sb = new StringBuilder();
sb.Append(@"{ ""Result"":""Success"", ""SiteUserCount"":""");
sb.Append(siteUserCount);
sb.Append(@""", ""SiteHydrantCount"":""");
sb.Append(siteHydrantCount);
sb.Append(@""", ""SiteTagCount"":""");
sb.Append(siteTagCount);
sb.Append(@""" }");
string temp = sb.ToString();
return(temp);
}
return(@"{ ""Result"":""Failure"" }");
}
private string HandleGetPendingTagsInTable(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
if (user.UserType == UserTypes.SuperUser ||
user.UserType == UserTypes.Administrator)
{
HydrantWikiManager hwManager = new HydrantWikiManager();
List <Tag> tags = hwManager.GetPendingTags();
TagTableResponse response = new TagTableResponse {
Result = "Success"
};
foreach (Tag tag in tags)
{
JsonObjects.ReviewTag jReviewTag = new JsonObjects.ReviewTag(tag);
User tagUser = (User)hwManager.GetUser(tag.UserGuid);
jReviewTag.Username = tagUser.GetUsernameWithSource();
response.Data.Add(jReviewTag);
}
string json = JsonConvert.SerializeObject(response);
return(json);
}
}
return(null);
}
public static bool IsAuthorized(Request _request, out User _user)
{
HydrantWikiManager hwManager = new HydrantWikiManager();
string username = _request.Headers["Username"].First();
string authToken = _request.Headers["AuthorizationToken"].First();
User user = hwManager.GetUser(UserSources.HydrantWiki, username);
if (user != null)
{
TGUserAuthorization userAuth = hwManager.GetUserAuthorization(user.Guid, authToken);
if (userAuth != null &&
!userAuth.IsExpired())
{
_user = user;
return(true);
}
}
_user = null;
return(false);
}
private BaseResponse HandleGetMyTagCount(DynamicDictionary _parameters)
{
User user;
BaseResponse response;
if (AuthHelper.IsAuthorized(Request, out user))
{
HydrantWikiManager hwm = new HydrantWikiManager();
int count = hwm.GetTagCount(user.Guid);
response = new TagCountResponse(true, count);
hwm.LogInfo(user.Guid, "Retrieved My Tag Count");
}
else
{
LogUnauthorized(Request);
response = new BaseResponse
{
Success = false,
Error = "Unauthorized",
Message = "Reauthenticate"
};
}
return(response);
}
public static string Authorize(string _username, string _password, out User _user)
{
HydrantWikiManager hwManager = new HydrantWikiManager();
_user = hwManager.GetUser(UserSources.HydrantWiki, _username);
if (_user != null)
{
if (_user.IsVerified)
{
if (_user.Active)
{
if (hwManager.ValidateUser(_user, _password))
{
TGUserAuthorization authorization =
TGUserAuthorization.GetNew(_user.Guid, "unknown");
hwManager.Persist(authorization);
//Done with a string builder to avoid the json braces that confuse string.format
StringBuilder sb = new StringBuilder();
sb.Append("{ \"Result\":\"Success\", \"AuthorizationToken\":\"");
sb.Append(authorization.AuthorizationToken);
sb.Append("\", \"DisplayName\":\"");
sb.Append(_user.DisplayName);
sb.Append("\", \"UserName\":\"");
sb.Append(_user.Username);
sb.Append("\" }");
return(sb.ToString());
}
//Bad password or username
hwManager.LogWarning(Guid.Empty, "User not found");
_user = null;
return(@"{ ""Result"":""BadUserOrPassword"" }");
}
//user not active
//Todo - Log Something
hwManager.LogWarning(_user.Guid, "User Not Active");
_user = null;
return(@"{ ""Result"":""NotActive"" }");
}
//User not verified
//Todo - Log Something
hwManager.LogWarning(_user.Guid, "User not verified");
_user = null;
return(@"{ ""Result"":""NotVerified"" }");
}
//User not found
hwManager.LogWarning(Guid.Empty, "User not found");
_user = null;
return(@"{ ""Result"":""BadUserOrPassword"" }");
}
static void DumpHydrants(string filename)
{
HydrantWikiManager manager = new HydrantWikiManager();
List <Hydrant> hydrants = manager.GetHydrants();
string body = JsonConvert.SerializeObject(hydrants);
//TODO Send to S3
File.WriteAllText(filename, body);
}
public string CreateYoTag(DynamicDictionary _parameters)
{
string username = Request.Query["username"];
string location = Request.Query["location"];
if (username != null &&
location != null)
{
GeoPoint geoPoint = null;
string[] locationParams = location.Split(";".ToCharArray());
if (locationParams.Length > 1)
{
geoPoint = new GeoPoint(Convert.ToDouble(locationParams[1]),
Convert.ToDouble(locationParams[0]));
}
if (geoPoint != null)
{
HydrantWikiManager hwm = new HydrantWikiManager();
User user = hwm.GetUser(UserSources.Yo, username);
if (user == null)
{
user = new User
{
UserSource = UserSources.Yo,
UserType = UserTypes.User,
Username = username,
Active = true
};
hwm.Persist(user);
}
Tag tag = new Tag
{
UserGuid = user.Guid,
Status = TagStatus.Pending,
DeviceDateTime = DateTime.UtcNow,
ExternalIdentifier = null,
ExternalSource = null,
Position = geoPoint
};
hwm.Persist(tag);
string url = Config.GetSettingValue("SystemUrl") + string.Format("/rest/yotag/{0}", tag.Guid);
YoHelper.SendYo(username, url);
}
}
return("");
}
private string AcceptTag(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
if (user != null &&
(user.UserType == UserTypes.SuperUser ||
user.UserType == UserTypes.Administrator))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
string sTagGuid = _parameters["tagGuid"];
Guid tagGuid;
if (Guid.TryParse(sTagGuid, out tagGuid))
{
Tag tag = hwManager.GetTag(tagGuid);
if (tag != null)
{
if (tag.Status == TagStatus.Pending)
{
Hydrant hydrant = new Hydrant
{
Active = true,
CreationDateTime = tag.DeviceDateTime,
LastModifiedBy = tag.LastModifiedBy,
LastModifiedDateTime = tag.LastModifiedDateTime,
LastReviewerUserGuid = user.Guid,
OriginalReviewerUserGuid = user.Guid,
OriginalTagDateTime = tag.DeviceDateTime,
OriginalTagUserGuid = tag.UserGuid,
Position = tag.Position,
PrimaryImageGuid = tag.ImageGuid
};
hwManager.Persist(hydrant);
tag.Status = TagStatus.Approved;
tag.HydrantGuid = hydrant.Guid;
hwManager.Persist(tag);
return(@"{ ""Result"":""Success"" }");
}
}
}
}
}
return(@"{ ""Result"":""Failure"" }");
}
private string MatchTagWithHydrant(DynamicDictionary _parameters)
{
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
if (user != null &&
(user.UserType == UserTypes.SuperUser ||
user.UserType == UserTypes.Administrator))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
string sTagGuid = _parameters["tagGuid"];
Guid tagGuid;
if (Guid.TryParse(sTagGuid, out tagGuid))
{
Tag tag = hwManager.GetTag(tagGuid);
if (tag != null)
{
if (tag.Status == TagStatus.Pending)
{
string sHydrantGuid = _parameters["hydrantGuid"];
Guid hydrantGuid;
if (Guid.TryParse(sHydrantGuid, out hydrantGuid))
{
Hydrant hydrant = hwManager.GetHydrant(hydrantGuid);
if (hydrant != null)
{
tag.Status = TagStatus.Approved;
tag.HydrantGuid = hydrantGuid;
hwManager.Persist(tag);
//TODO - Probably need to reaverage all tag positions and assign back to hydrant
hydrant.LastReviewerUserGuid = user.Guid;
hwManager.Persist(hydrant);
return(@"{ ""Result"":""Success"" }");
}
}
}
}
}
}
}
return(@"{ ""Result"":""Failure"" }");
}
private string IsAvailable(DynamicDictionary _parameters)
{
string username = _parameters["username"];
HydrantWikiManager hwm = new HydrantWikiManager();
User user = hwm.GetUser(UserSources.HydrantWiki, username);
if (user == null)
{
return("{ \"Available\":true }");
}
return("{ \"Available\":false }");
}
public string GetGeoboxCSVData(DynamicDictionary _parameters)
{
HydrantWikiManager hwm = new HydrantWikiManager();
double east = Convert.ToDouble((string)_parameters["east"]);
double west = Convert.ToDouble((string)_parameters["west"]);
double north = Convert.ToDouble((string)_parameters["north"]);
double south = Convert.ToDouble((string)_parameters["south"]);
GeoBox geobox = new GeoBox(east, west, north, south);
List <Hydrant> hydrants = hwm.GetHydrants(geobox);
return(HydrantCSVHelper.GetHydrantCSV(hydrants));
}
public static Dictionary <Guid, User> GetHydrantWikiUsers(this HydrantWikiManager _manager)
{
List <User> users = _manager.GetUsers();
Dictionary <Guid, User> output = new Dictionary <Guid, User>();
foreach (var user in users)
{
if (user.UserSource == UserSources.HydrantWiki)
{
output.Add(user.Guid, user);
}
}
return(output);
}
public BaseResponse HangleGetHydrantsByGeobox(DynamicDictionary _parameters)
{
var response = new BaseResponse {
Success = false
};
User user;
if (AuthHelper.IsAuthorized(Request, out user))
{
HydrantWikiManager hwm = new HydrantWikiManager();
double east = Convert.ToDouble((string)_parameters["east"]);
double west = Convert.ToDouble((string)_parameters["west"]);
double north = Convert.ToDouble((string)_parameters["north"]);
double south = Convert.ToDouble((string)_parameters["south"]);
int quantity = 250;
if (_parameters.ContainsKey("quantity"))
{
quantity = Convert.ToInt32((string)_parameters["quantity"]);
}
if (quantity > 500)
{
quantity = 500;
}
GeoBox geobox = new GeoBox(east, west, north, south);
List <Hydrant> hydrants = hwm.GetHydrants(geobox, quantity);
List <HydrantHeader> headers = ProcessHydrants(hydrants);
response = new HydrantQueryResponse {
Success = true, Hydrants = headers
};
hwm.LogInfo(user.Guid, "Retrieved Hydrants by Geobox");
return(response);
}
else
{
LogUnauthorized(Request);
}
return(response);
}
public IUserIdentity GetUserFromIdentifier(Guid _identifier, NancyContext _context)
{
HydrantWikiManager hwm = new HydrantWikiManager();
User user = (User)hwm.GetUser(_identifier);
if (user != null)
{
NancyUser nUser = new NancyUser {
UserName = user.Username
};
nUser.SetClaims(user.UserType);
return(nUser);
}
return(null);
}
private List <HydrantHeader> ProcessHydrants(IEnumerable <Hydrant> _hydrants, GeoPoint _center = null)
{
HydrantWikiManager hwm = new HydrantWikiManager();
Dictionary <Guid, string> users = new Dictionary <Guid, string>();
var output = new List <HydrantHeader>();
foreach (var hydrant in _hydrants)
{
string username;
Guid userGuid = hydrant.OriginalTagUserGuid;
if (users.ContainsKey(userGuid))
{
username = users[userGuid];
}
else
{
TGUser user = hwm.GetUser(userGuid);
users.Add(user.Guid, user.Username);
username = user.Username;
}
var outputHydrant = new HydrantHeader
{
HydrantGuid = hydrant.Guid,
Position = new GeoLocation(hydrant.Position.Y, hydrant.Position.X, 0),
ThumbnailUrl = hydrant.ThumbnailUrl,
ImageUrl = hydrant.ImageUrl,
Username = username
};
if (_center == null)
{
outputHydrant.DistanceInFeet = null;
}
else
{
outputHydrant.DistanceInFeet = PositionHelper.GetDistance(_center, hydrant.Position).ToFeet();
}
output.Add(outputHydrant);
}
return(output);
}
public BaseResponse ResetPasswordRequest(DynamicDictionary _parameters)
{
BaseResponse response = new BaseResponse();
string json = Request.Body.ReadAsString();
if (json != null)
{
ResetRequest rr = JsonConvert.DeserializeObject <ResetRequest>(json);
if (rr.Email != null &&
rr.InstallId != null)
{
HydrantWikiManager manager = new HydrantWikiManager();
User user = manager.GetUserByEmail(UserSources.HydrantWiki, rr.Email);
if (user != null)
{
//Send reset password email
PasswordReset reset = PasswordReset.GetNewRequest(user.Guid);
manager.Persist(reset);
NameValueCollection nvc = new NameValueCollection
{
{ "Code", reset.Code }
};
manager.SendCannedEmail(user, CannedEmailNames.ResetPasswordEmail, nvc);
manager.LogInfo(
user.Guid,
string.Format(
"Password Reset Request for user {0} on {1}",
user.Username,
rr.InstallId));
response.Success = true;
response.Message = "Password reset email sent.";
}
else
{
response.Success = false;
response.Message = "";
}
}
}
return(response);
}
public string GetCenterRadiusJsonData(double _latitude, double _longitude, double _distance)
{
HydrantWikiManager hwm = new HydrantWikiManager();
GeoPoint point = new GeoPoint(_longitude, _latitude);
List <NearbyHydrant> hydrants = hwm.GetNearbyHydrants(point, _distance);
NearbyHydrantTableResponse response = new NearbyHydrantTableResponse
{
Result = "Success",
Data = hydrants
};
string json = JsonConvert.SerializeObject(response);
return(json);
}
static void CalcLeaders(DateTime?_now = null)
{
DateTime now;
if (_now == null)
{
now = DateTime.UtcNow;
}
else
{
now = _now.Value;
}
HydrantWikiManager manager = new HydrantWikiManager();
List <Hydrant> hydrants = manager.GetHydrants();
Dictionary <Guid, User> users = manager.GetHydrantWikiUsers();
List <UserStats> final = users.Values.ToList().RebuildStats(now);
DailyStanding standing = manager.GetDailyStanding(now);
if (standing == null)
{
standing = new DailyStanding();
standing.Active = true;
standing.Date = now.Date;
standing.Guid = Guid.NewGuid();
standing.LastModifiedDateTime = now;
}
standing.ActiveUsers = final.Count;
//Sort and build daily standings based on new hydrants
List <Place> places = final.DeterminePlaces(UserStatSortColumn.NewHydrant);
Dictionary <Guid, DailyStandingUser> dsus = places.DetermineStanding(standing.Guid);
places = final.DeterminePlaces(UserStatSortColumn.ApprovedTags);
dsus = places.DetermineStanding(standing.Guid, dsus);
manager.Persist(final);
manager.Persist(standing);
manager.DeleteUserStandings(standing.Guid);
manager.Persist(dsus.Values.ToList());
}
private string Register(DynamicDictionary _parameters)
{
string username = Request.Headers["Username"].First();
string email = Request.Headers["Email"].First();
string password = Request.Headers["Password"].First();
HydrantWikiManager hwm = new HydrantWikiManager();
User user = hwm.GetUser(UserSources.HydrantWiki, username);
if (user == null)
{
user = new User
{
UserSource = UserSources.HydrantWiki,
IsVerified = false,
Active = true,
DisplayName = username,
EmailAddress = email,
UserType = UserTypes.User,
Username = username
};
hwm.Persist(user);
TGUserPassword userPassword = TGUserPassword.GetNew(user.Guid, username, password);
hwm.Persist(userPassword);
TGUserEmailValidation validation = new TGUserEmailValidation(user);
hwm.Persist(validation);
NameValueCollection nvc = new NameValueCollection
{
{ "SystemUrl", Config.GetSettingValue("SystemUrl") },
{ "ValidationText", validation.ValidationText }
};
hwm.SendCannedEmail(user, CannedEmailNames.ValidateEmailAddress, nvc);
return("{ \"Result\":\"Success\" }");
}
return("{ \"Result\":\"UsernameNotAvailable\" }");
}
public static Dictionary <Guid, TagStats> GetTagStatsByUser(this HydrantWikiManager _manager)
{
HydrantWikiManager manager = new HydrantWikiManager();
Dictionary <Guid, User> users = manager.GetHydrantWikiUsers();
Dictionary <Guid, TagStats> output = new Dictionary <Guid, TagStats>();
foreach (var userGuid in users.Keys)
{
List <Tag> tags = manager.GetTagsForUser(userGuid);
int tagCount = tags.Count;
int tagsRejected = 0;
int tagsApproved = 0;
int tagsPending = 0;
foreach (var tag in tags)
{
if (tag.Status == TagStatus.Approved)
{
tagsApproved++;
}
else if (tag.Status == TagStatus.Pending)
{
tagsPending++;
}
else if (tag.Status == TagStatus.Rejected)
{
tagsRejected++;
}
}
TagStats stats = new TagStats();
stats.ApprovedTagCount = tagsApproved;
stats.PendingTagCount = tagsPending;
stats.RejectedTagCount = tagsRejected;
output.Add(userGuid, stats);
}
return(output);
}
private Negotiator GetTagMap(DynamicDictionary _parameters)
{
if (_parameters != null &&
_parameters.ContainsKey("Guid") &&
GuidHelper.IsValidGuidString(_parameters["Guid"]))
{
Context.ViewBag.MapBoxMap = Config.GetSettingValue("MapBoxMap");
Context.ViewBag.MapBoxKey = Config.GetSettingValue("MapBoxKey");
Guid tagGuid = new Guid(_parameters["Guid"]);
HydrantWikiManager hwm = new HydrantWikiManager();
Tag tag = hwm.GetTag(tagGuid);
return(View["popupmap.sshtml", tag]);
}
return(null);
}
public static void CreateScaledImages(HydrantWikiManager _manager,
Guid _originalGuid)
{
//Get the image from the originals folder from S3
//Load the original
byte[] data = _manager.GetOriginal(_originalGuid, ".jpg");
try
{
using (Image full = ImageHelper.GetImage(data))
{
//Standard sizes must fit in 800 x 800
SizeF thumbSize = ImageSizeHelper.SizeThatFits(full, 800);
using (Image reduced = ImageHelper.GetThumbnail(full,
Convert.ToInt32(thumbSize.Height),
Convert.ToInt32(thumbSize.Width)))
{
data = ImageHelper.GetBytes(reduced, ImageFormat.Jpeg);
_manager.PersistWebImage(_originalGuid, ".jpg", "image/jpg", data);
}
//Thumbnails must fit in 100 x 100
thumbSize = ImageSizeHelper.SizeThatFits(full, 100);
using (Image reduced = ImageHelper.GetThumbnail(full,
Convert.ToInt32(thumbSize.Height),
Convert.ToInt32(thumbSize.Width)))
{
data = ImageHelper.GetBytes(reduced, ImageFormat.Jpeg);
_manager.PersistThumbnailImage(_originalGuid, ".jpg", "image/jpg", data);
}
}
}
catch (Exception ex)
{
//Bad Image
TraceFileHelper.Exception(ex);
}
}
private bool HandleGet(DynamicDictionary _parameters)
{
string validationToken = _parameters["validationtoken"];
if (!string.IsNullOrEmpty(validationToken))
{
HydrantWikiManager hwManager = new HydrantWikiManager();
TGUserEmailValidation uev = hwManager.GetTGUserEmailValidation(validationToken);
if (uev != null &&
uev.ParentGuid != null)
{
User user = (User)hwManager.GetUser(uev.ParentGuid.Value);
if (user != null)
{
user.IsVerified = true;
hwManager.Persist(user);
hwManager.Delete(uev);
return(true);
}
else
{
//User not found.
}
}
else
{
//Validation text not found in database
}
}
else
{
//Validation text not supplied.
}
return(false);
}
private string HandleChangePassword(DynamicDictionary _parameters)
{
string currentPassword = Request.Form["currentpassword"];
string newPassword = Request.Form["newpassword"];
string username = Request.Headers["Username"].First();
User user = null;
AuthHelper.Authorize(username, currentPassword, out user);
if (user != null)
{
TGUserPassword up = TGUserPassword.GetNew(user.Guid, user.Username, newPassword);
HydrantWikiManager hwm = new HydrantWikiManager();
hwm.Persist(up);
return(@"{ ""Result"":""Success"" }");;
}
return(@"{ ""Result"":""Failure"" }");
}
