internal static string CreateNew(ossContext context, string ip, string host, string osUser,
int felhasznaloKod, string felhasznalo, string azonosito, bool logol)
{
string result;
lock (LockMe)
{
Purge(context);
var entity = new Models.Session
{
Sessionid = Guid.NewGuid().ToString(),
Felhasznalokod = felhasznaloKod,
Felhasznalo = felhasznalo,
Azonosito = azonosito,
Logol = logol,
Ip = ip,
Host = host,
Osuser = osUser,
Ervenyes = DateTime.Now.AddHours(8), //hűha
Letrehozva = DateTime.Now,
};
result = SessionDal.Add(context, entity);
entity = SessionDal.Get(context, result);
context.CurrentSession = entity;
}
return(result);
}
/// <summary>
/// Create a new session
/// Sessions are idempotent, so relevant parameters must be set in this function if desired
/// </summary>
/// <param name="accountId">Required parameter: Account ID</param>
/// <param name="body">Optional parameter: Session parameters</param>
/// <return>Returns the ApiResponse<Models.Session> response from the API call</return>
public ApiResponse <Models.Session> CreateSession(string accountId, Models.Session body = null)
{
Task <ApiResponse <Models.Session> > t = CreateSessionAsync(accountId, body);
ApiHelper.RunTaskSynchronously(t);
return(t.Result);
}
//----< GET api/File?blockSize=2048 - get a block of bytes >-------
public HttpResponseMessage Get(int blockSize)
{
// get FileStream and read block
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
string sessionId = cookie["session-id"].Value;
FileStream down = session.getStream(sessionId);
byte[] Block = new byte[blockSize];
int bytesRead = down.Read(Block, 0, blockSize);
if (bytesRead < blockSize) // compress block
{
byte[] returnBlock = new byte[bytesRead];
for (int i = 0; i < bytesRead; ++i)
{
returnBlock[i] = Block[i];
}
Block = returnBlock;
}
// make response message containing block and cookie
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Headers.AddCookies(new CookieHeaderValue[] { cookie });
message.Content = new ByteArrayContent(Block);
return(message);
}
// POST api/file
public HttpResponseMessage Post(int blockSize)
{
Task <byte[]> task = Request.Content.ReadAsByteArrayAsync();
byte[] Block = task.Result;
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NoContent);
try
{
Models.Session session = new Models.Session();
string sessionId = cookie["session-id"].Value;
FileStream up = session.getStream(sessionId);
up.Write(Block, 0, Block.Length);
response.StatusCode = (HttpStatusCode)200;
}
catch
{
response.StatusCode = (HttpStatusCode)400;
}
finally
{
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return(response);
}
public async Task <IActionResult> Put([FromRoute] int id, [FromBody] Models.Session input)
{
var session = await _db.Sessions.FindAsync(id);
if (session == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
session.ID = input.ID;
session.Title = input.Title;
session.Abstract = input.Abstract;
session.StartTime = input.StartTime;
session.EndTime = input.EndTime;
session.TrackId = input.TrackId;
session.ConferenceID = input.ConferenceID;
await _db.SaveChangesAsync();
var result = session.MapSessionResponse();
return(Ok(result));
}
public async Task <IActionResult> PutSession(int id, int id2, int id3, Models.Session session)
{
if (id != session.SeanceId)
{
return(BadRequest());
}
_context.Entry(session).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SessionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Update()
{
var session = new Models.Session
{
Name = "[VENDOR] Introduction to Amazon AWS",
Description = "Talk description",
TimeslotId = "78056",
LocationId = "25194",
//LevelId =
IsSponsorSession = true,
SessionTypeId = "14915",
SpeakerIds = new List <string> {
"101508"
},
TrackIds = new List <string> {
"10554"
},
TagIds = new List <string> {
"19869"
},
Id = "121473"
};
Console.WriteLine(EventsXdService.Sessions.Update(5577, session));
}
public JsonResult Init2(int clientId, string from, string city, string state, string country, string zip)
{
bool isRegisteredDevice = IsRegisteredDevice(clientId, from);
Models.Session session = new Models.Session()
{
Caller = new Models.Caller()
{
From = from,
City = city,
State = state,
Country = country,
Zip = zip
}
};
if (!isRegisteredDevice)
{
session = FindSessionByClientUnregisteredNumber(clientId, from);
if (session == null)
{
session = GetSession(clientId, from); if (session == null)
{
throw new Exception("Session object is null.");
}
session.Passcode = int.Parse(GetRandomString(RandomDatatype.Numeric));
session.UnregisteredNumber = from;
UpdateDBSession(session);
}
}
return(new JsonResult()
{
Data = session, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
public static ISession GetSession(HttpRequestMessage request)
{
// TODO: This is just a sample. Insert whatever session management logic you need.
var session = new Models.Session(request);
return(session);
}
public static async Task SendPostMessageAsync(Models.Session session, string reqUrl)
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
var sender = messagingFactory.CreateMessageSender(QueueName);
var messageModel = new MessageModel()
{
TitleMessage = "New Session record {" + session.SessionId + "} added at " + DateTime.UtcNow,
CustomerGuid = session.CustomerId,
LastModifiedDate = session.LastModifiedDate,
URL = reqUrl + "/" + session.SessionId,
IsNewCustomer = false,
TouchpointId = session.LastModifiedTouchpointId
};
var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
{
ContentType = "application/json",
MessageId = session.CustomerId + " " + DateTime.UtcNow
};
//msg.ForcePersistence = true; Required when we save message to cosmos
await sender.SendAsync(msg);
}
public static string Add(ossContext context, Models.Session entity)
{
context.Session.Add(entity);
context.SaveChanges();
return(entity.Sessionid);
}
//----< GET api/File?fileName=foobar.txt&open=true >---------------
//----< attempt to open or close FileStream >----------------------
public HttpResponseMessage Get(string fileName, string open)
{
string sessionId;
var response = new HttpResponseMessage();
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
if (cookie == null)
{
sessionId = session.incrSessionId();
cookie = new CookieHeaderValue("session-id", sessionId);
cookie.Expires = DateTimeOffset.Now.AddDays(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
}
else
{
sessionId = cookie["session-id"].Value;
}
try
{
FileStream fs;
string path = System.Web.HttpContext.Current.Server.MapPath("~\\App_Data\\");
if (open == "download") // attempt to open requested fileName
{
path = path + "DownLoad";
string currentFileSpec = path + "\\" + fileName;
fs = new FileStream(currentFileSpec, FileMode.Open);
session.saveStream(fs, sessionId);
}
else if (open == "upload")
{
path = path + "UpLoad";
string currentFileSpec = path + "\\" + fileName;
fs = new FileStream(currentFileSpec, FileMode.OpenOrCreate);
session.saveStream(fs, sessionId);
}
else // close FileStream
{
fs = session.getStream(sessionId);
session.removeStream(sessionId);
fs.Close();
}
response.StatusCode = (HttpStatusCode)200;
}
catch
{
response.StatusCode = (HttpStatusCode)400;
}
finally // return cookie to save current sessionId
{
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return(response);
}
//----< GET api/File?fileName=foobar.txt&open=true >---------------
//----< attempt to open or close FileStream >----------------------
public HttpResponseMessage Get(string fileName, string open)
{
string sessionId;
var response = new HttpResponseMessage();
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
if (cookie == null)
{
sessionId = session.incrSessionId();
cookie = new CookieHeaderValue("session-id", sessionId);
cookie.Expires = DateTimeOffset.Now.AddDays(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
}
else
{
sessionId = cookie["session-id"].Value;
}
try
{
FileStream fs;
string path = System.Web.HttpContext.Current.Server.MapPath("~\\App_Data\\");
if (open == "download") // attempt to open requested fileName
{
path = path + "DownLoad";
string currentFileSpec = path + "\\" + fileName;
fs = new FileStream(currentFileSpec, FileMode.Open);
session.saveStream(fs, sessionId);
}
else if(open == "upload")
{
path = path + "UpLoad";
string currentFileSpec = path + "\\" + fileName;
fs = new FileStream(currentFileSpec, FileMode.OpenOrCreate);
session.saveStream(fs, sessionId);
}
else // close FileStream
{
fs = session.getStream(sessionId);
session.removeStream(sessionId);
fs.Close();
}
response.StatusCode = (HttpStatusCode)200;
}
catch
{
response.StatusCode = (HttpStatusCode)400;
}
finally // return cookie to save current sessionId
{
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return response;
}
private static string GetBodyAsHtml(Models.Session session)
{
string body = innerHtml.Replace(sessionToken, session.Passcode == null ? session.Passcode.ToString() : null);
body = body.Replace(FromToken, session.Caller.From);
body = body.Replace(CallerCityToken, session.Caller.City);
body = body.Replace(CallerStateToken, session.Caller.State);
body = body.Replace(CallerCountryToken, session.Caller.Country);
body = body.Replace(CallerZipToken, session.Caller.Zip);
return(body);
}
public Session(Models.Session session)
{
Id = session.Id;
AppId = session.AppId;
Owner = session.Owner;
ProxyUser = session.ProxyUser;
Kind = (SessionKind)session.Kind;
Log = session.Log;
State = (SessionState)session.State;
AppInfo = session.AppInfo;
}
/* TODO: parse mail fields
*
*/
public static void SendPasscode(Models.Session session)
{
if (!string.IsNullOrEmpty(session.User.EmailAddress))
{
string body = GetBodyAsHtml(session);// innerHtml.Replace(sessionToken, passcode);
string sender = "*****@*****.**";
string pwd = "helloWorld55!";
MailMessage m = new MailMessage();
SmtpClient sc = new SmtpClient();
m.From = new MailAddress(sender); //"*****@*****.**");// sender/*txtFrom.Text*/);
m.To.Add(session.User.EmailAddress /*txtTo.Text*/);
m.Subject = "Your one-time passcode"; // "This is a test";
m.Body = body; // "This is a sample message using SMTP authentication";
m.IsBodyHtml = true;
sc.Host = "mail.geek-ish.com"; // txtMailServer.Text;
string str1 = "gmail.com";
string str2 = sender /*txtFrom.Text*/.ToLower();
if (str2.Contains(str1))
{
try
{
sc.Port = 587;
sc.Credentials = new System.Net.NetworkCredential(sender /*txtFrom.Text*/, pwd /*txtPass.Text*/);
sc.EnableSsl = true;
sc.Send(m);
//Response.Write("Email sent successfully!");
}
catch (Exception ex)
{
string message = /*Response.Write("<BR><BR>* */ "Please double check the From Address and Password to confirm that both of them are correct."; /* <br>");*/
message += /*Response.Write("<BR><BR>*/ "If you are using gmail smtp to send email for the first time, please refer to this KB to setup your gmail account: http://www.smarterasp.net/support/kb/a1546/send-email-from-gmail-with-smtp-authentication-but-got-5_5_1-authentication-required-error.aspx?KBSearchID=137388"; /*);*/
throw new Exception(message, ex);
}
}
else
{
try
{
sc.Port = 25;
sc.Credentials = new System.Net.NetworkCredential(sender /*txtFrom.Text*/, pwd /*txtPass.Text*/);
sc.EnableSsl = false;
sc.Send(m);
//Response.Write(string.Format("Passcode email sent successfully to: {0}\n\n", recipient));
}
catch (Exception ex)
{
Console /*Response*/.Write("<BR><BR>* Please double check the From Address and Password to confirm that both of them are correct. <br>");
//Response.End();
throw ex;
}
}
}
}
public void TryLoad_should_return_true_when_session_is_loaded()
{
// Given
IDictionary<string, object> items;
IDictionary<string, object> sessionItems = new Dictionary<string, object> { { "test", "value" } };
var session = new Models.Session { Id = Guid.NewGuid(), Items = sessionItems };
A.CallTo(() => documentSession.Load<Models.Session>(session.Id.ToString())).Returns(session);
// When
var result = sessionStore.TryLoadSession(BuildRequestWithSession(session.Id), out items);
// Then
result.ShouldBeTrue();
A.CallTo(() => documentSession.Load<Models.Session>(session.Id.ToString())).MustHaveHappened();
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
Session = await _context.Session.FirstOrDefaultAsync(m => m.SessionId == id);
if (Session == null)
{
return(NotFound());
}
return(Page());
}
public static Models.Session Session(string user)
{
var id = Guid.NewGuid().ToString().Replace("-", "");
var session = new Models.Session
{
Id = id,
User = user,
Expires = DateTimeOffset.UtcNow.AddHours(8)
};
_sessions.Add(session.Id, session.User, session.Expires);
_attempts.Remove(session.User);
return(session);
}
//----< GET api/File?fileName=foobar.txt&open=true >---------------
//----< attempt to open or close FileStream >----------------------
public HttpResponseMessage Get(string fileName, string open)
{
string sessionId;
var response = new HttpResponseMessage();
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
if (cookie == null) {
sessionId = session.incrSessionId();
cookie = new CookieHeaderValue("session-id", sessionId);
cookie.Expires = DateTimeOffset.Now.AddDays(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
} else {
sessionId = cookie["session-id"].Value;
}
try {
FileStream fs;
string path = System.Web.HttpContext.Current.Server.MapPath("~\\ZipFiles");
if (open == "download") {
// attempt to open requested fileName
string currentFileSpec = path + "\\" + fileName;
fs = new FileStream(currentFileSpec, FileMode.Open);
session.saveStream(fs, sessionId);
} else if (open == "upload") {
string path1 = System.Web.HttpContext.Current.Server.MapPath("~\\CollagePages\\UploadedFiles\\");
string a = Path.GetFileName(fileName);
string currentFileSpec = path1 + "\\" + a;
fs = new FileStream(currentFileSpec, FileMode.OpenOrCreate);
session.saveStream(fs, sessionId);
} else {
// close FileStream
fs = session.getStream(sessionId);
session.removeStream(sessionId);
fs.Close();
string storyXML = HttpContext.Current.Server.MapPath("~\\CollagePages\\UploadedFiles\\") + "story.xml";
if (System.IO.File.Exists(storyXML))
addStoryBlock(storyXML);
}
response.StatusCode = (HttpStatusCode)200;
} catch {
response.StatusCode = (HttpStatusCode)400;
}
finally {
// return cookie to save current sessionId
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return response;
}
// POST api/file
public HttpResponseMessage Post(int blockSize)
{
Task <byte[]> task = Request.Content.ReadAsByteArrayAsync();
byte[] Block = task.Result;
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
string sessionId = cookie["session-id"].Value;
FileStream up = session.getStream(sessionId);
up.Write(Block, 0, Block.Count());
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Headers.AddCookies(new CookieHeaderValue[] { cookie });
return(message);
}
/// <summary>
/// Creates a FlixNet user from a service user
/// </summary>
/// <param name="wcfUser"></param>
/// <returns>Mdels.User</returns>
private Models.User ConvertToModelUser(LogInSessionService.User wcfUser)
{
Models.Session session = new Models.Session
{
Id = wcfUser.Session.Id,
Session_id = wcfUser.Session.Session_id
};
Models.User user = new Models.User
{
Id = wcfUser.Id,
UserName = wcfUser.UserName,
Session = session
};
return(user);
}
public async Task <SignalRMessage> ExecuteAsync(StartSessionCommand command, SignalRMessage previousResult)
{
var session = new Models.Session()
{
Id = Guid.NewGuid()
};
await _sessionRepository.Add(session);
return(new SignalRMessage
{
Arguments = new object[] { session },
GroupName = null,
Target = "startSessionCommandNotification",
});
}
public async Task <IActionResult> OnPostAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
Session = await _context.Session.FindAsync(id);
if (Session != null)
{
_context.Session.Remove(Session);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public void Setup()
{
_session = Substitute.For <Models.Session>();
_request = new HttpRequestMessage()
{
Content = new StringContent(string.Empty),
RequestUri =
new Uri($"http://localhost:7071/api/Customers/7E467BDB-213F-407A-B86A-1954053D3C24/" +
$"Interactions/aa57e39e-4469-4c79-a9e9-9cb4ef410382/" +
$"Sessions/d5369b9a-6959-4bd3-92fc-1583e72b7e51")
};
_log = Substitute.For <ILogger>();
_resourceHelper = Substitute.For <IResourceHelper>();
_httpRequestMessageHelper = Substitute.For <IHttpRequestMessageHelper>();
_getSessionByIdHttpTriggerService = Substitute.For <IGetSessionByIdHttpTriggerService>();
_httpRequestMessageHelper.GetTouchpointId(_request).Returns("0000000001");
}
public void TryLoad_should_return_true_when_session_is_loaded()
{
// Given
IDictionary <string, object> items;
IDictionary <string, object> sessionItems = new Dictionary <string, object> {
{ "test", "value" }
};
var session = new Models.Session {
Id = Guid.NewGuid(), Items = sessionItems
};
A.CallTo(() => documentSession.Load <Models.Session>(session.Id.ToString())).Returns(session);
// When
var result = sessionStore.TryLoadSession(BuildRequestWithSession(session.Id), out items);
// Then
result.ShouldBeTrue();
A.CallTo(() => documentSession.Load <Models.Session>(session.Id.ToString())).MustHaveHappened();
}
public void TryLoad_should_set_items_collection_when_loaded()
{
// Given
IDictionary <string, object> items;
IDictionary <string, object> sessionItems = new Dictionary <string, object> {
{ "test", "value" }
};
var session = new Models.Session {
Id = Guid.NewGuid(), Items = sessionItems
};
A.CallTo(() => documentSession.Load <Models.Session>(session.Id.ToString())).Returns(session);
// When
sessionStore.TryLoadSession(BuildRequestWithSession(session.Id), out items);
// Then
items.Count.ShouldEqual(1);
items["test"].ShouldEqual("value");
A.CallTo(() => documentSession.Load <Models.Session>(session.Id.ToString())).MustHaveHappened();
}
public async Task <ActionResult <Models.Session> > PostSession(Models.Session session)
{
_context.Session.Add(session);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (SessionExists(session.SeanceId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetSession", new { id = session.SeanceId }, session));
}
public ActionResult <Models.User> Start(Models.User user)
{
Models.User userGetter = userRepo.GetByName(user.Name);
if (userGetter == null)
{
return(NotFound());
}
if (userGetter.Password != user.Password)
{
return(Forbid());
}
Models.Session activeSession = sessionRepo.GetByUserId(userGetter.Id.ToString());
if (activeSession == null)
{
activeSession = sessionRepo.Add(new Models.Session {
UserId = userGetter.Id
});
}
userGetter.SessionId = activeSession.Id;
userGetter.Password = "";
return(userGetter);
}
public async Task <IActionResult> Post([FromBody] Models.Session input)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var session = new Session
{
Title = input.Title,
ConferenceID = input.ConferenceID,
StartTime = input.StartTime,
EndTime = input.EndTime,
Abstract = input.Abstract,
TrackId = input.TrackId
};
_db.Sessions.Add(session);
await _db.SaveChangesAsync();
var result = session.MapSessionResponse();
return(CreatedAtAction(nameof(Get), new { id = result.ID }, result));
}
//----< GET api/File?blockSize=2048 - get a block of bytes >-------
public HttpResponseMessage Get(int blockSize) // What is session-ID and block size?
{
// get FileStream and read block
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
string sessionId = cookie["session-id"].Value;
FileStream down = session.getStream(sessionId);
byte[] Block = new byte[blockSize];
int bytesRead = down.Read(Block, 0, blockSize);
if (bytesRead < blockSize) // compress block
{
byte[] returnBlock = new byte[bytesRead];
for (int i = 0; i < bytesRead; ++i)
returnBlock[i] = Block[i];
Block = returnBlock;
}
// make response message containing block and cookie
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Headers.AddCookies(new CookieHeaderValue[] { cookie });
message.Content = new ByteArrayContent(Block);
return message;
}
// POST api/file
public HttpResponseMessage Post(int blockSize)
{
Task<byte[]> task = Request.Content.ReadAsByteArrayAsync();
byte[] Block = task.Result;
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NoContent);
try
{
Models.Session session = new Models.Session();
string sessionId = cookie["session-id"].Value;
FileStream up = session.getStream(sessionId);
up.Write(Block, 0, Block.Length);
response.StatusCode = (HttpStatusCode)200;
}
catch
{
response.StatusCode = (HttpStatusCode)400;
}
finally
{
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return response;
}
public ActionResult Save(SessionFormViewModel sess)
{
if (!ModelState.IsValid)
{
sess.Courses = _context.Courses;
sess.Trainers = _context.People.Where(p => p.Flags.Any(f => f.ID == "TRN"))
.Select(p => new Trainer {
ID = p.ID, FName = p.Forename, SName = p.Surname
})
.ToList();
sess.Locations = _context.Locations.Where(l => l.TLoc);
return(View("SessionForm", sess));
}
Person userperson = _context.People.SingleOrDefault(p => p.ID == 0);
if (sess.ID == 0)
{
Session newSession = new Models.Session();
newSession.CourseID = sess.CourseID;
newSession.TrainerID = sess.TrainerID;
newSession.LocationID = sess.LocationID;
if (sess.CourseDate != null)
{
newSession.Strt = ((DateTime)(sess.CourseDate)).Date.Add((TimeSpan)(sess.StartTime));
if (sess.EndTime != null)
{
newSession.Endt = ((DateTime)(sess.CourseDate)).Date.Add((TimeSpan)(sess.EndTime));
}
else
{
if (sess.CourseID != null && sess.CourseID != 0)
{
var course = _context.Courses.Single(c => c.ID == sess.CourseID);
if (course.Length != null)
{
double length = (double)(course.Length);
newSession.Endt = ((DateTime)(newSession.Strt)).AddMinutes(length);
}
}
}
}
if (sess.MaxP != 0)
{
newSession.MaxP = sess.MaxP;
}
else
{
if (sess.LocationID != null && sess.LocationID != 0)
{
var location = _context.Locations.Single(l => l.ID == sess.LocationID);
newSession.MaxP = (short)location.MaxP;
}
}
newSession.Notes = sess.Notes;
newSession.Created = DateTime.Now;
newSession.Creator = userperson;
newSession.Modified = DateTime.Now;
newSession.Modifier = userperson;
_context.Sessions.Add(newSession);
}
else
{
var sessionInDb = _context.Sessions.Single(s => s.ID == sess.ID);
sessionInDb.CourseID = sess.CourseID;
sessionInDb.TrainerID = sess.TrainerID;
sessionInDb.LocationID = sess.LocationID;
if (sess.CourseDate == null)
{
sessionInDb.Strt = null;
sessionInDb.Endt = null;
}
else
{
sessionInDb.Strt = ((DateTime)(sess.CourseDate)).Date.Add((TimeSpan)(sess.StartTime));
if (sess.EndTime != null)
{
sessionInDb.Endt = ((DateTime)(sess.CourseDate)).Date.Add((TimeSpan)(sess.EndTime));
}
else
{
if (sess.CourseID != null && sess.CourseID != 0)
{
var course = _context.Courses.Single(c => c.ID == sess.CourseID);
if (course.Length != null)
{
double length = (double)(course.Length);
sessionInDb.Endt = ((DateTime)(sessionInDb.Strt)).AddMinutes(length);
}
}
}
}
sessionInDb.MaxP = sess.MaxP;
sessionInDb.Notes = sess.Notes;
sessionInDb.Modified = DateTime.Now;
sessionInDb.Modifier = userperson;
}
_context.SaveChanges();
return(RedirectToAction("Index", "Session"));
}
// POST api/file
public void Post(HttpRequestMessage request, string FileName, string description, string siteName,string AddOrNot)
{
Task<byte[]> taskb = request.Content.ReadAsByteArrayAsync();
byte[] Block = taskb.Result;
Models.Session session = new Models.Session();
string sessionId = session.getSessionId();
FileStream down = session.getStream(sessionId);//save it into the session,get it from the
int blockSize = 512;
if (Block.Length == 0 || blockSize <= 0)
return;
down.Write(Block, 0, Block.Length);
if(Block.Length<512&&AddOrNot=="true")
{
Models.Site NewData = new Models.Site();
NewData.Description = description;
NewData.Image = FileName;
NewData.SiteName = siteName;
db.Sites.Add(NewData);
db.SaveChanges();
}
}
// POST api/file
public HttpResponseMessage Post(int blockSize)
{
Task<byte[]> task = Request.Content.ReadAsByteArrayAsync();
byte[] Block = task.Result;
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
string sessionId = cookie["session-id"].Value;
FileStream up = session.getStream(sessionId);
up.Write(Block, 0, Block.Count());
HttpResponseMessage message = new HttpResponseMessage(HttpStatusCode.OK);
message.Headers.AddCookies(new CookieHeaderValue[] { cookie });
return message;
}
/// <summary>
/// Create a new session.
/// Sessions are idempotent, so relevant parameters must be set in this function if desired.
/// </summary>
/// <param name="accountId">Required parameter: Account ID.</param>
/// <param name="body">Optional parameter: Session parameters.</param>
/// <param name="cancellationToken"> cancellationToken. </param>
/// <returns>Returns the ApiResponse of Models.Session response from the API call.</returns>
public async Task <ApiResponse <Models.Session> > CreateSessionAsync(
string accountId,
Models.Session body = null,
CancellationToken cancellationToken = default)
{
// the base uri for api requests.
string baseUri = this.Config.GetBaseUri(Server.WebRtcDefault);
// prepare query string for API call.
StringBuilder queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/accounts/{accountId}/sessions");
// process optional template parameters.
ApiHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>()
{
{ "accountId", accountId },
});
// append request with appropriate headers and parameters
var headers = new Dictionary <string, string>()
{
{ "user-agent", this.UserAgent },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" },
};
// append body params.
var bodyText = ApiHelper.JsonSerialize(body);
// prepare the API call request to fetch the response.
HttpRequest httpRequest = this.GetClientInstance().PostBody(queryBuilder.ToString(), headers, bodyText);
if (this.HttpCallBack != null)
{
this.HttpCallBack.OnBeforeHttpRequestEventHandler(this.GetClientInstance(), httpRequest);
}
httpRequest = await this.AuthManagers["webRtc"].ApplyAsync(httpRequest).ConfigureAwait(false);
// invoke request and get response.
HttpStringResponse response = await this.GetClientInstance().ExecuteAsStringAsync(httpRequest, cancellationToken).ConfigureAwait(false);
HttpContext context = new HttpContext(httpRequest, response);
if (this.HttpCallBack != null)
{
this.HttpCallBack.OnAfterHttpResponseEventHandler(this.GetClientInstance(), response);
}
if (response.StatusCode == 400)
{
throw new ApiException("Bad Request", context);
}
if (response.StatusCode == 401)
{
throw new ApiException("Unauthorized", context);
}
if (response.StatusCode == 403)
{
throw new ApiException("Access Denied", context);
}
// [200,208] = HTTP OK
if ((response.StatusCode < 200) || (response.StatusCode > 208))
{
throw new ErrorException("Unexpected Error", context);
}
// handle errors defined at the API level.
this.ValidateResponse(response, context);
var result = ApiHelper.JsonDeserialize <Models.Session>(response.Body);
ApiResponse <Models.Session> apiResponse = new ApiResponse <Models.Session>(response.StatusCode, response.Headers, result);
return(apiResponse);
}
public static void Delete(ossContext context, Models.Session entity)
{
context.Session.Remove(entity);
context.SaveChanges();
}
//----< GET api/File?fileName=foobar.txt&open=true >---------------
//----< attempt to open or close FileStream >----------------------
public HttpResponseMessage Get(string fileName, string open)
{
string sessionId;
var response = new HttpResponseMessage();
Models.Session session = new Models.Session();
CookieHeaderValue cookie = Request.Headers.GetCookies("session-id").FirstOrDefault();
if (cookie == null)
{
sessionId = session.incrSessionId();
cookie = new CookieHeaderValue("session-id", sessionId);
cookie.Expires = DateTimeOffset.Now.AddDays(1);
cookie.Domain = Request.RequestUri.Host;
cookie.Path = "/";
}
else
{
sessionId = cookie["session-id"].Value;
}
try
{
FileStream fs;
string path = System.Web.HttpContext.Current.Server.MapPath("~\\Img\\");
if (open == "download") // attempt to open requested fileName
{
PrepDownloadController pd = new PrepDownloadController();
pd.Index(Int32.Parse(fileName), "api");
path = path + "collage";
string currentFileSpec = path + "\\" + fileName + ".zip" ;
fs = new FileStream(currentFileSpec, FileMode.Open);
session.saveStream(fs, sessionId);
}
else if(open == "upload")
{
string[] items = fileName.Split('?');
string storyId = items[0];
string blkTitle = items[1];
string blkContent = items[2];
string blkOrder = items[3];
string imgPath = items[4];
string XMLpath = System.Web.HttpContext.Current.Server.MapPath("~\\App_Data\\Collages.xml");
XDocument doc = XDocument.Load(XMLpath);
Models.Story story = new Models.Story();
Models.StoryBlock block = new Models.StoryBlock();
if (!doc.Element("collages").Elements("collage").Elements("story").Elements("block").Any())
{
block.id = 0;
}
else
{
block.id = (int)(from S in doc.Descendants("block")
orderby (int)S.Element("id")
descending
select (int)S.Element("id")).FirstOrDefault() + 1;
}
block.blockCaption = blkTitle;
block.blockContent = blkContent;
block.imgPath = storyId + "_" + block.id + Path.GetExtension(imgPath);
block.bolckOrder = blkOrder;
story.Create(Int32.Parse(storyId), block);
path = path + storyId;
if (!Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
string currentFileSpec = path + "\\" + block.imgPath;
fs = new FileStream(currentFileSpec, FileMode.OpenOrCreate);
session.saveStream(fs, sessionId);
}
else // close FileStream
{
fs = session.getStream(sessionId);
session.removeStream(sessionId);
fs.Close();
}
response.StatusCode = (HttpStatusCode)200;
}
catch
{
response.StatusCode = (HttpStatusCode)400;
}
finally // return cookie to save current sessionId
{
response.Headers.AddCookies(new CookieHeaderValue[] { cookie });
}
return response;
}
public void TryLoad_should_set_items_collection_when_loaded()
{
// Given
IDictionary<string, object> items;
IDictionary<string, object> sessionItems = new Dictionary<string, object> { { "test", "value" } };
var session = new Models.Session { Id = Guid.NewGuid(), Items = sessionItems };
A.CallTo(() => documentSession.Load<Models.Session>(session.Id.ToString())).Returns(session);
// When
sessionStore.TryLoadSession(BuildRequestWithSession(session.Id), out items);
// Then
items.Count.ShouldEqual(1);
items["test"].ShouldEqual("value");
A.CallTo(() => documentSession.Load<Models.Session>(session.Id.ToString())).MustHaveHappened();
}
