protected async Task <Response> Refresh(RefreshInfo refreshInfo)
{
var res = await this.DomainService.ServiceRefreshRow(refreshInfo);
return(new ChunkedResult <RefreshInfo>(res, this.Serializer));
//return Response.AsJson(res);
}
public Border(Vector2f dimension, EMode mode = EMode.Window, Boolean noBackgroundMode = false)
{
Dimension = dimension;
Mode = mode;
NoBackgroundMode = noBackgroundMode;
if (!NoBackgroundMode)
Background = new Texture(Border.WindowBackgroundTexture);
Visible = true;
Borders = new Dictionary<BorderType, List<Sprite>>();
foreach (BorderType borderType in Enum.GetValues(typeof(BorderType)))
Borders[borderType] = new List<Sprite>();
Corners = new Dictionary<CornerType, Sprite>();
RefreshInfo = new RefreshInfo();
Color = DEFAULT_AMBIENT_COLOR;
BackgroundAlphaFactor = DEFAULT_BACKGROUND_ALPHA_FACTOR;
Build();
}
public async Task RefreshAsync(RefreshInfo info)
{
switch (info.RefreshType)
{
case RefreshType.Event:
case RefreshType.Session:
_messageBus.StartEventRefresh();
EventState state = await RefreshEvent();
if (_messageBus != null)
{
_messageBus.RefreshEvent(state);
}
break;
case RefreshType.Ticket:
Guid ticketId = info.Id;
TicketState ticket = await _service.GetTicket(ticketId);
if (ticket != null)
{
await _cache.PutAsync(ticketId, ticket);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public Task <Product> RefreshProduct(RefreshInfo refreshInfo)
{
return(Task.Run <Product>(() =>
{
return this.GetRefreshedEntity <Product>(this.DB.Products, refreshInfo);
}));
}
public static T GetRefreshedEntity <T>(this IServicesProvider dataService, IQueryable <T> entities,
RefreshInfo info)
where T : class
{
var keyValue = info.rowInfo.GetPKValues(dataService.ServiceContainer.DataHelper);
var dbEntity = FindEntity(entities, info.rowInfo, keyValue);
return((T)dbEntity);
}
public Form1()
{
InitializeComponent();
m_TwainManager = new TwainManager(m_StrProductKey);
m_ImageCore = new ImageCore();
dsViewer1.Bind(m_ImageCore);
dsViewer1.SetViewMode(1, 1);
BMPradio.Checked = true;
sImageType = 0;
MultiTIFF.Enabled = false;
MultiPDF.Enabled = false;
m_PDFCreator = new PDFCreator(m_StrProductKey);
m_RefreshInfo = new RefreshInfo(ShowImageInfo);
}
public HttpResponseMessage RefreshToken([FromBody] RefreshInfo refreshInfo)
{
User user = db.User.Where(usr => usr.Id == refreshInfo.Id).FirstOrDefault();
if (user == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "User was not found"));
}
Guid UserRefreshToken = user.RefreshToken.GetValueOrDefault();
if (UserRefreshToken == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "There is not refresh token"));
}
if (UserRefreshToken.ToString() == refreshInfo.RefreshToken)
{
DateTime now = DateTime.UtcNow;
DateTime RefreshTokenExpirationDate = user.RefreshTokenExpirationDate.GetValueOrDefault();
if (RefreshTokenExpirationDate > now)
{
//Guid newRefreshToken = Guid.NewGuid();
//DateTime newRefreshTokenExpirationDate = DateTime.UtcNow.AddDays(1);
//user.RefreshToken = newRefreshToken;
//user.RefreshTokenExpirationDate = newRefreshTokenExpirationDate;
//db.SaveChanges();
AuthInfo authenticationInfo = new AuthInfo()
{
UserId = user.Id, NickName = user.Nickname, JWT_Token = JWT_Manager.GenerateToken(user.Id, user.Nickname, 5), RefreshToken = UserRefreshToken.ToString()
};
return(Request.CreateResponse(HttpStatusCode.OK, authenticationInfo));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Refresh token expired"));
}
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Wrong refresh token"));
}
}
public void LoadRefreshInfosFromXml(SecurityElement element)
{
if (element.Children != null)
{
foreach (SecurityElement element2 in element.Children)
{
string str;
if (((str = element2.Tag) != null) && (str == "RefreshInfo"))
{
RefreshInfo item = new RefreshInfo {
Index = StrParser.ParseDecInt(element2.Attribute("Index"), 0),
RefreshTime = StrParser.ParseDateTime(element2.Attribute("RefreshTime")),
RefreshType = TypeNameContainer <_RefreshType> .Parse(element2.Attribute("RefreshType"), 0)
};
this._refreshInfos.Add(item);
}
}
}
}
protected async Task <RefreshInfo> RefreshRowInfo(RefreshInfo info)
{
var metadata = MetadataHelper.GetInitializedMetadata(this);
info.dbSetInfo = metadata.dbSets[info.dbSetName];
var methodData = metadata.getOperationMethodInfo(info.dbSetName, MethodType.Refresh);
if (methodData == null)
{
throw new InvalidOperationException(string.Format(ErrorStrings.ERR_REC_REFRESH_INVALID,
info.dbSetInfo.EntityType.Name, GetType().Name));
}
info.rowInfo.dbSetInfo = info.dbSetInfo;
var authorizer = ServiceContainer.Authorizer;
authorizer.CheckUserRightsToExecute(methodData);
var req = new RequestContext(this, rowInfo: info.rowInfo, operation: ServiceOperationType.RowRefresh);
using (var callContext = new RequestCallContext(req))
{
var instance = _serviceHelper.GetMethodOwner(methodData);
var invokeRes = methodData.methodInfo.Invoke(instance, new object[] { info });
var dbEntity = await ServiceOperationsHelper.GetMethodResult(invokeRes).ConfigureAwait(false);
var rri = new RefreshInfo {
rowInfo = info.rowInfo, dbSetName = info.dbSetName
};
if (dbEntity != null)
{
_serviceHelper.UpdateRowInfoFromEntity(dbEntity, info.rowInfo);
}
else
{
rri.rowInfo = null;
}
return(rri);
}
}
public async Task <RefreshInfo> ServiceRefreshRow(RefreshInfo refreshInfo)
{
RefreshInfo res = null;
try
{
res = await RefreshRowInfo(refreshInfo);
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException)
{
ex = ex.InnerException;
}
res = new RefreshInfo
{
dbSetName = refreshInfo.dbSetName,
error = new ErrorInfo(ex.GetFullMessage(), ex.GetType().Name),
rowInfo = null
};
_OnError(ex);
}
return(res);
}
public virtual async Task <IHttpActionResult> Refresh(HttpRequestMessage request, RefreshInfo refreshInfo)
{
var svc = DataService;
if (svc == null)
{
var response = Request.CreateResponse(HttpStatusCode.NotFound, "Service not found");
throw new HttpResponseException(response);
}
var res = await svc.ServiceRefreshRow(refreshInfo).ConfigureAwait(false);
return(new ChunkedActionResult <RefreshInfo>(request, res, _serializer));
}
public Task <Product> RefreshProduct(RefreshInfo refreshInfo)
{
return(Task.Run(() => { return DataService.GetRefreshedEntity(DB.Products, refreshInfo); }));
}
public async Task <ActionResult> Refresh([SericeParamsBinder] RefreshInfo refreshInfo)
{
var res = await DomainService.ServiceRefreshRow(refreshInfo).ConfigureAwait(false);
return(new ChunkedResult <RefreshInfo>(res, Serializer));
}
public Customer RefreshCustomer(RefreshInfo refreshInfo)
{
return(this.GetRefreshedEntity(DB.Customers, refreshInfo));
}
