public HttpResponseMessage Hotel(IncomingBoundingBoxLocation location)
{
return(ErrorFactory.Handle(() =>
{
var currentUserId = User?.Identity?.GetUserId();
if (string.IsNullOrWhiteSpace(currentUserId))
{
throw new UnauthorizedAccessException();
}
using (var unitOfWork = new UnitOfWork())
{
var theLocation = LocationBounded.FromDegrees(location.Latitude, location.Longitude);
var boundingBox = theLocation.BoundingCoordinates(location.Distance);
if (boundingBox.Length != 2)
{
throw new Exception("The bounding box is not in the correct format.");
}
var bottomLeft = boundingBox[0].ConvertToLatLonLocation();
var topRight = boundingBox[1].ConvertToLatLonLocation();
var hotels = unitOfWork.Hotels.GetHotelsInRadius(currentUserId, bottomLeft, topRight, location.Distance).ToList();
var outgoingHotels = hotels.Select(x => OutgoingHotel.Parse(x)).ToList();
return JsonFactory.CreateJsonMessage(outgoingHotels, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public async Task <HttpResponseMessage> ForgotPassword(string email)
{
return(await ErrorFactory.Handle(async() =>
{
if (string.IsNullOrWhiteSpace(email))
{
throw new InvalidModelException();
}
var user = await UserManager.FindByEmailAsync(email);
if (user == null)
{
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "ok"
}, HttpStatusCode.OK, this.Request);
}
var token = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
await this.SendForgotPasswordEmail(user, token);
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "ok"
}, HttpStatusCode.OK, this.Request);
}, this.Request));
}
public async Task <HttpResponseMessage> ChangePassword(IncomingChangePassword model)
{
return(await ErrorFactory.Handle(async() =>
{
var userID = User.Identity.GetUserId();
if (userID == null)
{
throw new Exception();
}
var pwResult = await UserManager.PasswordValidator.ValidateAsync(model.NewPassword);
if (pwResult.Succeeded == false)
{
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "Invalid password", Action = "invalidPassword"
}, HttpStatusCode.Forbidden, this.Request);
}
var result = await UserManager.ChangePasswordAsync(userID, model.CurrentPassword, model.NewPassword);
if (result.Succeeded == false)
{
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "Invalid username password combo", Action = "invalidUsernamePassword"
}, HttpStatusCode.Forbidden, this.Request);
}
return GetInformationForCurrentUserResponseMessage(userID);
}, this.Request));
}
/// <summary>
/// 将当前对象转化为其他类型，转化失败返回null
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static TResult ToObject <TResult>(this object obj)
{
string json;
var provider = JsonFactory.GetProvider();
if (provider == null)
{
return(default(TResult));
}
try
{
if (obj is string)
{
json = obj.ToString();
}
else
{
json = provider.SerializeObject(obj);
}
return(provider.DeserializeObject <TResult>(json));
}
catch (Exception)
{
return(default(TResult));
}
}
private IManageFile GetManageFile(EnumType fileType)
{
IStudentFactory abstractFactory;
switch (fileType)
{
case EnumType.TXT:
{
abstractFactory = new TxtFactory();
return(abstractFactory.Create());
}
case EnumType.XML:
{
abstractFactory = new XmlFactory();
return(abstractFactory.Create());
}
default:
{
abstractFactory = new JsonFactory();
return(abstractFactory.Create());
}
}
}
public void JsonFactoryGetIgnoredPropertiesDoesntThrowANullReferenceException()
{
var propList = JsonFactory.GetIgnoredProperties(null);
Assert.NotNull(propList);
Assert.IsEmpty(propList);
}
/// <summary>
/// Initializes the class.
/// </summary>
/// <param name="type">The type.</param>
public static void InitializeClass(Type type)
{
Console.WriteLine(
type.GetMembers(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public).Count());
foreach (var member in GetFieldsAndProperties(type))
{
var valueType = member.GetMemberType();
var import = member.GetCustomAttribute <ResourceImportAttribute>();
var value = JsonFactory.JsonResource(import.File, valueType);
if (import.Filter != null)
{
if (
!import.Filter.GetInterfaces()
.Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IFilter <>)))
{
throw new Exception($"{nameof(import.Filter)} does not implement {nameof(IFilter)}");
}
var filterInstance = Activator.CreateInstance(import.Filter);
var apply = import.Filter.GetMethod("Apply", BindingFlags.Public | BindingFlags.Instance);
value = apply.Invoke(filterInstance, new[] { value });
}
member.SetValue(null, value);
}
}
public HttpResponseMessage CheckStatus(int id)
{
return(ErrorFactory.Handle(() =>
{
var userId = User?.Identity?.GetUserId();
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception();
}
using (var unitOfWork = new UnitOfWork())
{
var reservation = unitOfWork.Reservations.CheckStatus(userId, id);
if (reservation == null)
{
return JsonFactory.CreateJsonMessage(null, HttpStatusCode.OK, this.Request);
}
unitOfWork.Complete();
var outgoingReservation = OutgoingMinimalReservationGroup.Parse(reservation);
return JsonFactory.CreateJsonMessage(outgoingReservation, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public void Serialize_Deserialize()
{
FleetTemplate fleetTemplate = new FleetTemplate();
fleetTemplate.Add(new AGVTemplate()
{
IPV4String = "192.168.0.1", PoseDataString = "0,0,90"
});
fleetTemplate.Add(new AGVTemplate()
{
IPV4String = "192.168.0.2", PoseDataString = "10,0,90"
});
string json = fleetTemplate.ToJson();
Assert.IsNotNull(json);
string filePath = Path.GetTempFileName();
File.WriteAllText(filePath, json);
FleetTemplate fleetTemplateLoaded = JsonFactory.FleetTemplateFromFile(filePath);
Assert.IsNotNull(fleetTemplateLoaded);
CollectionAssert.IsNotEmpty(fleetTemplateLoaded.AGVTemplates);
}
public void Save()
{
var unityPackageManifestPath = Path.Combine(Project.UnityProjectRoot, "Packages", "manifest.json");
var factory = new JsonFactory <UnityPackageManifest>();
factory.Serialize(unityPackageManifestPath, this);
}
public HttpResponseMessage GetUserReservations(IncomingGetUsersReservations model)
{
return(ErrorFactory.Handle(() =>
{
using (var unitOfWork = new UnitOfWork())
{
var userId = User?.Identity?.GetUserId();
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception();
}
if (model == null)
{
throw new InvalidModelException();
}
var reservations = unitOfWork.Reservations.GetReservationsForUser(userId, model.UserId, model.StartDate, model.EndDate);
var outgoingReservations = reservations?.Select(x => OutgoingMinimalReservationGroupExtra.Parse(x));
return JsonFactory.CreateJsonMessage(outgoingReservations, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public static void Default_0_GetInstance()
{
JsonFactory.Register <JsonFactoryImpl>();
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
}
private static Voice[] GetVoices()
{
Voice[] voices = null;
var audio = Find.Any <InteractionAudio>();
if (audio != null)
{
var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
var assetsRoot = Path.Combine(userProfile, "Box", "VR Initiatives", "Engineering", "Assets");
var keyFile = Path.Combine(assetsRoot, "DevKeys", "azure-speech.txt");
if (File.Exists(keyFile))
{
var lines = File.ReadAllLines(keyFile);
var azureApiKey = lines[0];
var azureRegion = lines[1];
var cache = audio.GetCachingStrategy();
var voicesDecoder = new JsonFactory <Voice[]>();
var voicesClient = new VoicesClient(azureRegion, azureApiKey, voicesDecoder, cache);
var voicesTask = voicesClient.GetVoicesAsync();
voices = voicesTask.Result;
}
}
return(voices);
}
public HttpResponseMessage SearchEmployees(IncomingHotelUserSearch userQuery)
{
return(ErrorFactory.Handle(() =>
{
var userId = User?.Identity?.GetUserId();
if (userId == null)
{
throw new Exception("User not found.");
}
if (userQuery == null)
{
throw new InvalidModelException("hotelQuery cannot be null");
}
using (var unitOfWork = new UnitOfWork())
{
var hotels = unitOfWork.Hotels.SearchHotelUsers(userId, userQuery.HotelId, userQuery.Query, userQuery.StartsWith, userQuery.NumberToGet);
var outgoingHotels = hotels.ToList().Select(x => OutgoingHotelUser.Parse(x)).ToList();
return JsonFactory.CreateJsonMessage(outgoingHotels, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public HttpResponseMessage EditVenue(IncomingEditVenue addVenue)
{
return(ErrorFactory.Handle(() =>
{
var userId = User?.Identity?.GetUserId();
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception();
}
using (var unitOfWork = new UnitOfWork())
{
var editVenue = unitOfWork.Venues.EditVenue(userId, addVenue);
unitOfWork.Complete();
try
{
editVenue = unitOfWork.Venues.GetVenueById(userId, editVenue.Id);
}
catch (Exception)
{
}
var outgoingVenue = OutgoingVenue.Parse(editVenue);
return JsonFactory.CreateJsonMessage(outgoingVenue, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public static void Default_6_SerializeObject_WithList()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var classList = new List <TestClass1>();
var class1 = new TestClass1
{
TestBool1 = true,
TestInt1 = 3,
TestString1 = "test"
};
classList.Add(class1);
var class2 = new TestClass1
{
TestInt1 = 5
};
classList.Add(class2);
var result = jsonFactory.SerializeObject(classList);
Assert.NotNull(result);
Assert.Equal("[{\"TestBool1\":true,\"TestInt1\":3,\"TestLong1\":0,\"TestString1\":\"test\"},{\"TestBool1\":false,\"TestInt1\":5,\"TestLong1\":0,\"TestString1\":null}]", result);
}
public HttpResponseMessage AddBlackout(Blackout blackout)
{
return(ErrorFactory.Handle(() =>
{
var userId = User?.Identity?.GetUserId();
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception();
}
using (var unitOfWork = new UnitOfWork())
{
var bl = unitOfWork.Venues.CreateBlackout(userId, blackout);
unitOfWork.Complete();
var outBl = new Blackout
{
Id = bl.Id,
StartDate = bl.StartDate,
EndDate = bl.EndDate,
VenueId = bl.VenueId
};
var outgoingBlackout = OutgoingVenueBlackout.Parse(outBl);
return JsonFactory.CreateJsonMessage(outgoingBlackout, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
public void Default_6_SerializeObject_WithListOfDictionary()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var dict = new Dictionary <string, string>
{
{ "testKey0", "testValue0" },
{ "testKey1", "testValue1" },
{ "testKey2", "testValue2" }
};
var dict2 = new Dictionary <string, string>
{
{ "testKey0", "testValue3" },
{ "testKey2", "testValue4" },
{ "testKey4", "testValue5" }
};
var dictList = new List <Dictionary <string, string> >
{
dict,
dict2
};
var result = jsonFactory.SerializeObject(dictList);
_output.WriteLine("Serialized string: " + result);
Assert.Equal("[{\"testKey0\":\"testValue0\",\"testKey1\":\"testValue1\",\"testKey2\":\"testValue2\"},{\"testKey0\":\"testValue3\",\"testKey2\":\"testValue4\",\"testKey4\":\"testValue5\"}]", result);
}
public void JsonFactoryGetIgnoredPropertiesReturnsListOfIgnoredProperties()
{
var propList = JsonFactory.GetIgnoredProperties(new SampleSObject());
var ignoreList = string.Join(", ", propList.OrderBy(p => p));
Assert.AreEqual("IgnoredDate, IgnoredString", ignoreList);
}
public static void Default_7_DeserializeObject()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var class1 = new TestClass1
{
TestBool1 = true,
TestInt1 = 3,
TestLong1 = 10,
TestString1 = "test"
};
var result = jsonFactory.SerializeObject(class1);
Assert.NotNull(result);
Assert.Equal("{\"TestBool1\":true,\"TestInt1\":3,\"TestLong1\":10,\"TestString1\":\"test\"}", result);
var deserializedClass1 = jsonFactory.DeserializeObject <TestClass1>(result);
Assert.Equal(class1.TestBool1, deserializedClass1.TestBool1);
Assert.Equal(class1.TestInt1, deserializedClass1.TestInt1);
Assert.Equal(class1.TestLong1, deserializedClass1.TestLong1);
Assert.Equal(class1.TestString1, deserializedClass1.TestString1);
class1 = new TestClass1
{
TestLong1 = 1000000000000
};
result = jsonFactory.SerializeObject(class1);
deserializedClass1 = jsonFactory.DeserializeObject <TestClass1>(result);
Assert.Equal(class1.TestLong1, deserializedClass1.TestLong1);
}
public void SaveData()
{
Dictionary <int, Tile> tile_map = mTileMap.GetTileMap();
List <int> map_tile_list = new List <int>();
for (int i = 0; i < Const.TileCntY; i++)
{
for (int j = 0; j < Const.TileCntX; j++)
{
int index = (i * Const.TileCntX) + j;
Tile tile = null;
if (tile_map.ContainsKey(index))
{
tile = tile_map[index];
}
if (tile == null)
{
map_tile_list.Add(0);
}
else
{
map_tile_list.Add((int)tile.GetTileType());
}
}
}
MapData map_data = new MapData();
map_data.MapName = Const.MapDataName;
map_data.MapDta = map_tile_list;
JsonFactory.Write(Const.MapDataName, map_data);
}
public static void JsonArray_05_ParseLong()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var jsonArray = jsonFactory.CreateJsonArray();
Assert.NotNull(jsonArray);
Assert.Equal("[]", jsonArray.ToString());
jsonArray.Insert(0, 100000000000L);
var value = jsonArray.ParseLong(0);
Assert.Equal(100000000000L, value);
jsonArray.Insert(1, "200000000001");
var value2 = jsonArray.ParseLong(1);
Assert.Equal(200000000001L, value2);
jsonArray.Insert(1, 300000000002L);
var value3 = jsonArray.ParseLong(1);
Assert.Equal(300000000002, value3);
jsonArray.Insert(1, 1);
var value4 = jsonArray.ParseLong(1);
Assert.Equal(1L, value4);
}
/// <summary>
/// Dumps the configuration of hierarchy of queues with
/// the xml file path given.
/// </summary>
/// <remarks>
/// Dumps the configuration of hierarchy of queues with
/// the xml file path given. It is to be used directly ONLY FOR TESTING.
/// </remarks>
/// <param name="out">the writer object to which dump is written to.</param>
/// <param name="configFile">the filename of xml file</param>
/// <exception cref="System.IO.IOException"/>
internal static void DumpConfiguration(TextWriter @out, string configFile, Configuration
conf)
{
if (conf != null && conf.Get(DeprecatedQueueConfigurationParser.MapredQueueNamesKey
) != null)
{
return;
}
JsonFactory dumpFactory = new JsonFactory();
JsonGenerator dumpGenerator = dumpFactory.CreateJsonGenerator(@out);
QueueConfigurationParser parser;
bool aclsEnabled = false;
if (conf != null)
{
aclsEnabled = conf.GetBoolean(MRConfig.MrAclsEnabled, false);
}
if (configFile != null && !string.Empty.Equals(configFile))
{
parser = new QueueConfigurationParser(configFile, aclsEnabled);
}
else
{
parser = GetQueueConfigurationParser(null, false, aclsEnabled);
}
dumpGenerator.WriteStartObject();
dumpGenerator.WriteFieldName("queues");
dumpGenerator.WriteStartArray();
DumpConfiguration(dumpGenerator, parser.GetRoot().GetChildren());
dumpGenerator.WriteEndArray();
dumpGenerator.WriteEndObject();
dumpGenerator.Flush();
}
void SetSocket()
{
// 소켓 설치
gameObject.AddComponent <ClientNet>();
mNet = GetComponent <ClientNet>();
// @request UID 발급 신청
StructRequest request = new StructRequest();
request.uid = "";
request.request_url = URL.InitUser.ToString();
void CallBack(StructRequest response)
{
if (response.uid != null)
{
mUserData = new StructUserData();
mUserData.uid = response.uid;
mUserData.isPVPMode = true;
string map_data = response.parameter["mapData"];
string item_data = response.parameter["itemData"];
// 맵 데이터에 저장
JsonFactory.WriteString(Const.MapDataName, map_data);
mUserData.itemData = item_data;
}
}
mNet.SetCallBack(CallBack);
mNet.RequestMsg(request);
}
public async Task <HttpResponseMessage> Login(IncomingLogin credentials)
{
return(await ErrorFactory.Handle(async() =>
{
var result = await SignInManager.PasswordSignInAsync(credentials.Email, credentials.Password, credentials.RememberMe, shouldLockout: true);
switch (result)
{
case SignInStatus.Success:
ApplicationUser user = await UserManager.FindByNameAsync(credentials.Email);
return GetInformationForCurrentUserResponseMessage(user.Id);
case SignInStatus.LockedOut:
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "Your account is locked out. Please try again later.", Action = "lockedOut"
}, HttpStatusCode.Forbidden, Request);
case SignInStatus.RequiresVerification:
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "Your email requires verification. Please check your email and follow the instructions.", Action = "verificationRequired"
}, HttpStatusCode.Forbidden, this.Request);
case SignInStatus.Failure:
default:
return JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "Invalid username/password combination", Action = "invalidCredentials"
}, HttpStatusCode.Forbidden, this.Request);
}
}, this.Request));
}
// PVP
public void GotoPVPGame()
{
// @request 상대 UID 요청
StructRequest request = new StructRequest();
request.uid = mUserData.uid;
request.request_url = URL.GetOpponentData.ToString();
void mCallBack(StructRequest response)
{
if (response.parameter != null)
{
if (response.parameter["opponentUid"] != null)
{
StructUserData user_data = mUserData;
user_data.opponentUid = response.parameter["opponentUid"];
// 발급받은 UID는 로컬 데이터에 저장
JsonFactory.Write(Const.UserDataName, user_data);
// 상대 클라이언트가 준비되었다면 게임 실행
SceneManager.LoadScene("GameScene");
}
}
}
mNet.SetCallBack(mCallBack);
mNet.RequestMsg(request);
}
private HttpResponseMessage GetInformationForCurrentUserResponseMessage(string userID)
{
if (string.IsNullOrWhiteSpace(userID))
{
try
{
LogoutNoRoute();
}
catch (Exception)
{
}
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "An unknown error has occured.", Action = "unknownError"
}, HttpStatusCode.Forbidden, this.Request));
}
using (var unitOfWork = new UnitOfWork())
{
var realUserInformation = unitOfWork.Users.GetUserByIdForLogin(userID, userID);
if (realUserInformation == null)
{
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "An unknown error has occured.", Action = "unknownError"
}, HttpStatusCode.Forbidden, this.Request));
}
var outgoingInformation = OutgoingPersonalUser.Parse(realUserInformation);
return(JsonFactory.CreateJsonMessage(outgoingInformation, HttpStatusCode.OK, this.Request));
}
}
public HttpResponseMessage GetMessagesForUser(int numberOfDays)
{
return(ErrorFactory.Handle(() =>
{
var userId = User.Identity.GetUserId();
if (userId == null)
{
throw new Exception();
}
if (numberOfDays <= 0)
{
throw new Exception();
}
using (var unitOfWork = new UnitOfWork())
{
var response = unitOfWork.Miscellaneous.GetMessagesForNumberOfDays(userId, numberOfDays);
var outgoingResponse = response?.Select(x => OutgoingInboxMessage.Parse(x))?.ToList();
return JsonFactory.CreateJsonMessage(outgoingResponse, HttpStatusCode.OK, this.Request);
}
}, this.Request));
}
void SetUserData()
{
string data = JsonFactory.Load(Const.UserDataName);
StructUserData _data = JsonUtility.FromJson <StructUserData>(data);
Const.UserData = _data;
}
//[DebuggerStepThrough]
public static async Task <HttpResponseMessage> Handle(Func <Task <HttpResponseMessage> > functionToRun, HttpRequestMessage request)
{
try
{
return(await functionToRun());
}
catch (BeginTransactionException e)
{
return(JsonFactory.CreateJsonMessage(e.Summary, HttpStatusCode.InternalServerError, request));
}
catch (AlreadyDisposedException e)
{
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = e.Message, DetailedMessage = e.DetailedMessage, Action = e.Action, DetailedAction = e.DetailedAction
}, HttpStatusCode.InternalServerError, request));
}
catch (UnauthorizedAccessException)
{
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = "You are not authorized to view this content.", Action = "unauthorized"
}, HttpStatusCode.Forbidden, request));
}
catch (BaseException e)
{
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = e.Message, DetailedMessage = e.DetailedMessage, Action = e.Action, DetailedAction = e.DetailedAction
}, HttpStatusCode.InternalServerError, request));
}
catch (Exception e)
{
return(JsonFactory.CreateJsonMessage(new OutgoingMessage {
Message = e.Message
}, HttpStatusCode.InternalServerError, request));
}
}
