public async Task<IHttpActionResult> Execute([FromODataUri] int key, ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var arg1 = (string)parameters["Argument"];
var arg2 = (string)parameters["Argument2"];
try
{
using (var context = new ZvsContext(WebApi2Plugin.EntityContextConnection))
{
var command = await context.Commands.FirstOrDefaultAsync(o => o.Id == key);
if (command == null)
return NotFound();
var result = await WebApi2Plugin.RunCommandAsync(command.Id, arg1, arg2, CancellationToken.None);
if (result.HasError)
return BadRequest(result.Message);
return Ok(result.Message);
}
}
catch (Exception e)
{
return BadRequest(e.Message);
}
}
public void Can_find_action(string actionName, string url)
{
ODataDeserializerContext context = new ODataDeserializerContext { Request = GetPostRequest(url), Model = GetModel() };
IEdmFunctionImport action = new ODataActionParameters().GetFunctionImport(context);
Assert.NotNull(action);
Assert.Equal(actionName, action.Name);
}
public Movie CreateMovie(ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
string title = parameters["Title"] as string;
Movie movie = new Movie()
{
Title = title
};
try
{
db.Movies.Add(movie);
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
return movie;
}
public IHttpActionResult IncreasePrice([FromODataUri] int key, ODataActionParameters parameters)
{
var entity = DbContext.Products.FirstOrDefault(e => e.ProductID == key);
if (entity == null)
{
return NotFound();
}
entity.UnitPrice = entity.UnitPrice + (int)parameters["diff"];
try
{
DbContext.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DbContext.Products.Any(p => p.ProductID == key))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public void Throws_InvalidOperation_when_action_not_found()
{
ODataDeserializerContext context = new ODataDeserializerContext { Request = GetPostRequest("http://server/service/MissingOperation"), Model = GetModel() };
Assert.Throws<InvalidOperationException>(() =>
{
IEdmFunctionImport action = new ODataActionParameters().GetFunctionImport(context);
}, "The request URI 'http://server/service/MissingOperation' was not recognized as an OData path.");
}
public void Throws_InvalidOperation_when_multiple_overloads_found()
{
ODataDeserializerContext context = new ODataDeserializerContext { Request = GetPostRequest("http://server/service/Vehicles/System.Web.Http.OData.Builder.TestModels.Car(8)/Park"), Model = GetModel() };
InvalidOperationException ioe = Assert.Throws<InvalidOperationException>(() =>
{
IEdmFunctionImport action = new ODataActionParameters().GetFunctionImport(context);
}, "Action resolution failed. Multiple actions matching the action identifier 'Park' were found. The matching actions are: org.odata.Container.Park, org.odata.Container.Park.");
}
public Customer ChangeName(int parentId, ODataActionParameters odataParams)
{
IndividualCustomer ic = new IndividualCustomer();
ic.Id = 1;
ic.Name = "kiran";
ic.SSN = "111111111";
return ic;
}
public virtual Vehicle Drive(int boundId, ODataActionParameters actionParams)
{
return new Motorcycle()
{
Id = 1,
Model = "Toyota",
Name = "Tacoma"
};
}
public IHttpActionResult ChangePersonStatus(ODataActionParameters parameters)
{
if (ModelState.IsValid)
{
var level = parameters["Level"];
// SAVE THIS TO THE DATABASE OR WHATEVER....
}
return Ok(true);
}
public IHttpActionResult CreateVedioAc(ODataActionParameters parameters)
{
Vedio vedio = parameters["vedio"] as Vedio;
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
_db.Vedio.Add(vedio);
return Created(vedio);
//return Created("sss");
}
public void Can_find_action_overload_using_bindingparameter_type()
{
string url = "http://server/service/Vehicles(8)/System.Web.Http.OData.Builder.TestModels.Car/Wash";
ODataDeserializerContext context = new ODataDeserializerContext { Request = GetPostRequest(url), Model = GetModel() };
IEdmFunctionImport action = new ODataActionParameters().GetFunctionImport(context);
Assert.NotNull(action);
Assert.Equal("Wash", action.Name);
}
public string DiscontinueProduct(ODataActionParameters actionParams)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
int productToDiscontinue = (int)actionParams["id"];
//return _db.Products.Where(p => p.ID == productToDiscontinue).Single();
return "success";
}
public IHttpActionResult AddOptionalShape(int key, ODataActionParameters parameters)
{
Shape newShape = parameters["shape"] as Shape;
Window window = _windows.FirstOrDefault(e => e.Id == key);
if (window == null)
{
return NotFound();
}
window.OptionalShapes.Add(newShape);
int count = window.OptionalShapes.Count;
return Ok(count);
}
public IHttpActionResult Purchase([FromODataUri] int key, ODataActionParameters parameters)
{
int amount = (int)parameters["AmountOfShoes"];
var customer = db.Customers.First(c => c.Id == key);
var invoices = CustomerService.PurchaseShoesAndSendMail(customer, amount);
if (!invoices.Any())
{
return NotFound();
}
return Ok(invoices);
}
public IHttpActionResult Rate([FromODataUri] int key, ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var rating = (int)parameters["Rating"];
_productAgent.AddRating(new ProductRating { ProductId = key, Rating = rating });
return StatusCode(HttpStatusCode.NoContent);
}
public Product ExtendSupportDate(int boundId, ODataActionParameters actionParams)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, this.ModelState));
}
Product prd = _db.Products.Where(p => p.ID == boundId).Single();
////prd.SupportedUntil = (DateTime)actionParams["newDate"];
////_db.SaveChanges();
return prd;
}
/// <inheritdoc />
public override object Read(ODataMessageReader messageReader, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
// Create the correct resource type;
ODataActionParameters payload = new ODataActionParameters();
IEdmFunctionImport action = GetFunctionImport(readContext);
ODataParameterReader reader = messageReader.CreateODataParameterReader(action);
while (reader.Read())
{
string parameterName = null;
IEdmFunctionParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
payload[parameterName] = Convert(reader.Value, parameter.Type, readContext);
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
payload[parameterName] = Convert(reader.CreateCollectionReader(), collectionType, readContext);
break;
default:
break;
}
}
return payload;
}
public IHttpActionResult AddAccessLevel(int key, ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return BadRequest();
}
String accessLevelOfString = (String)parameters["AccessLevel"];
AccessLevel accessLevelOfAccesslevel = (AccessLevel)Enum.Parse(typeof(AccessLevel), accessLevelOfString);
Employee employee = _employees.Single(e => e.ID == key);
if (null == employee)
{
return BadRequest();
}
employee.AccessLevel |= accessLevelOfAccesslevel;
return Ok(employee.AccessLevel);
}
public IHttpActionResult CreateMovie(ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
string title = parameters["Title"] as string;
Movie movie = new Movie()
{
Title = title,
ID = _db.Movies.Count + 1,
};
_db.Movies.Add(movie);
return Created(movie);
}
public IHttpActionResult CheckOutMany(ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// Client passes a list of movie IDs to check out.
var movieIDs = new HashSet<int>(parameters["MovieIDs"] as IEnumerable<int>);
// Try to check out each movie in the list.
var results = new List<Movie>();
foreach (Movie movie in _db.Movies.Where(m => movieIDs.Contains(m.ID)))
{
if (TryCheckoutMovie(movie))
{
results.Add(movie);
}
}
// Return a list of the movies that were checked out.
return Ok(results);
}
public IHttpActionResult AdvancedAction(ODataActionParameters parameters)
{
Assert.NotNull(parameters);
Assert.Equal(new[] { 4, 5, 6 }, parameters["nums"] as IEnumerable<int>);
Assert.Equal(new[] { ConventionGender.Male, ConventionGender.Female }, parameters["genders"] as IEnumerable<ConventionGender>);
IList<ConventionAddress> newAddress = (parameters["addresses"] as IEnumerable<ConventionAddress>).ToList();
Assert.Single(newAddress);
foreach (ConventionAddress addr in newAddress.Concat(new[] {parameters["location"]}))
{
Assert.Equal("NY Rd.", addr.Street);
Assert.Equal("Redmond", addr.City);
Assert.Equal("9011", addr.ZipCode);
}
IList<ConventionCustomer> newCustomers = (parameters["customers"] as IEnumerable<ConventionCustomer>).ToList();
Assert.Single(newAddress);
foreach (ConventionCustomer cust in newCustomers.Concat(new[] { parameters["customer"] }))
{
Assert.Equal(8, cust.ID);
Assert.Equal("Mike", cust.Name);
Assert.Null(cust.Address);
}
return Ok();
}
public async Task <IHttpActionResult> SaveInternalStakeHolder([FromODataUri] int key, ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//int rating = (int)parameters["Rating"];
//Product product = await db.Products.FindAsync(key);
//if (product == null)
//{
// return NotFound();
//}
//product.Ratings.Add(new ProductRating() { Rating = rating });
//db.SaveChanges();
//double average = product.Ratings.Average(x => x.Rating);
return(Ok());
}
public IHttpActionResult Update([FromODataUri] long key, ODataActionParameters parameters)
{
if (parameters["dto"] == null)
{
throw new Exception("输入参数错误");
}
var dto = parameters["dto"] as QuestionUpdateInputDto;
this.Validate(dto);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var questionEntity = Db.Question.Find(key);
if (questionEntity == null)
{
return(NotFound());
}
using (var transaction = Db.Database.BeginTransaction())
{
questionEntity.Title = dto.Title;
questionEntity.Important = dto.Important;
questionEntity.Sticky = dto.Sticky;
questionEntity.Text = dto.Text;
questionEntity.UpdatedTime = DateTime.Now;
questionEntity.UpdatedBy = User.Identity.Name;
var contentEntity = questionEntity.MapToContent();
Db.Content.Attach(contentEntity);
Db.Entry(contentEntity).State = System.Data.Entity.EntityState.Modified;
foreach (var item in Db.Tag.Where(m => m.ContentId == key))
{
Db.Tag.Remove(item);
}
foreach (var item in dto.Tags)
{
Db.Tag.Add(new Tag
{
ContentId = questionEntity.Id,
ContentType = ContentTypeEnum.Question.ToString(),
Value = item,
});
}
try
{
Db.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(Updated(questionEntity));
}
public IHttpActionResult Clear(ODataActionParameters paras)
{
return(Ok());
}
public virtual async Task <IHttpActionResult> Generate(ODataActionParameters parameters)
{
if (!CheckPermission(WritePermission))
{
return(Unauthorized());
}
int tenantId = GetTenantId();
var config = await Service.FindAsync(x => x.TenantId == tenantId);
var file = new SitemapXmlFile();
var pageVersions = await pageVersionService.FindAsync(x => x.TenantId == tenantId);
var urls = new HashSet <UrlElement>();
List <string> cultures = null;
using (var connection = languageService.Value.OpenConnection())
{
cultures = await connection
.Query(x => x.TenantId == tenantId)
.Select(x => x.CultureCode)
.ToListAsync();
}
string siteUrl = Request.RequestUri.GetLeftPart(UriPartial.Authority);
// For each Page
foreach (var item in config)
{
var invariantVersion = pageVersions.First(x => x.CultureCode == null && x.Id == item.PageId);
if (cultures.HasMoreThan(1))
{
var localizedVersions = pageVersions
.Where(x =>
x.PageId == invariantVersion.PageId &&
x.CultureCode != null);
// For each Language
foreach (string culture1 in cultures)
{
var localizedVersion1 = localizedVersions
.Where(x => x.CultureCode == culture1)
.OrderByDescending(x => x.DateModifiedUtc)
.FirstOrDefault();
if (localizedVersion1 == null)
{
localizedVersion1 = invariantVersion;
}
var links = new List <LinkElement>();
// For each Language (again)
foreach (string culture2 in cultures)
{
// If this language is the same as the one in the outer loop
if (culture2 == culture1)
{
// ignore this loop and continue to next...
continue;
}
var localizedVersion2 = localizedVersions
.Where(x => x.CultureCode == culture2)
.OrderByDescending(x => x.DateModifiedUtc)
.FirstOrDefault();
if (localizedVersion2 == null)
{
localizedVersion2 = invariantVersion;
}
links.Add(new LinkElement
{
Rel = "alternate",
HrefLang = culture2,
Href = string.Concat(siteUrl, "/", localizedVersion2.Slug)
});
}
links.Add(new LinkElement
{
Rel = "alternate",
HrefLang = culture1,
Href = string.Concat(siteUrl, "/", localizedVersion1.Slug)
});
urls.Add(new UrlElement
{
Location = string.Concat(siteUrl, "/", localizedVersion1.Slug),
LastModified = localizedVersion1.DateModifiedUtc.ToString("yyyy-MM-dd"),
ChangeFrequency = item.ChangeFrequency,
Priority = item.Priority,
Links = links.OrderBy(x => x.HrefLang).ToList()
});
}
}
else
{
if (invariantVersion == null && cultures.Count == 1)
{
// If there's only 1 language configured, then we use that as the default
string cultureCode = cultures.First();
invariantVersion = pageVersions.First(x => x.CultureCode == cultureCode && x.Id == item.PageId);
}
urls.Add(new UrlElement
{
Location = string.Concat(siteUrl, "/", invariantVersion.Slug),
LastModified = invariantVersion.DateModifiedUtc.ToString("yyyy-MM-dd"),
ChangeFrequency = item.ChangeFrequency,
Priority = item.Priority,
Links = null
});
}
}
file.Urls = urls.OrderBy(x => x.Location).ToHashSet();
try
{
var xmlns = new XmlSerializerNamespaces();
xmlns.Add("xhtml", "http://www.w3.org/1999/xhtml");
file.XmlSerialize(
HostingEnvironment.MapPath(string.Format("~/sitemap-{0}.xml", tenantId)),
omitXmlDeclaration: false,
xmlns: xmlns,
encoding: Encoding.UTF8);
// For some reason, just returning Ok() with no parameter causes the following client-side error:
// "unexpected end of data at line 1 column 1 of the JSON data"
// TODO: Perhaps we should be returning null instead? Or perhaps we should change the method to return void
// Also, we should look throughout the solution for the same issue in other controllers.
return(Ok(string.Empty));
}
catch (Exception x)
{
Logger.Error(x.Message, x);
return(InternalServerError(x));
}
}
public IQueryable <Premise> Get(ODataActionParameters parameters)
{
return(db.Premises);
}
public IHttpActionResult Rate([FromODataUri] int key, ODataActionParameters parameters)
{
return StatusCode(HttpStatusCode.NoContent);
}
public IHttpActionResult Create(ODataActionParameters parameters)
{
var product = new Product
{
Id = Data.Values.Max(existingProduct => existingProduct.Id) + 1,
Name = (string)parameters["name"],
Price = (double)parameters["price"],
EnumValue = (MyEnum)parameters["enumValue"]
};
Data.TryAdd(product.Id, product);
return Created(product);
}
public HttpResponseMessage ValidateXML(ODataActionParameters parameters)
{
if (!ModelState.IsValid || !parameters.ContainsKey("documentContent"))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
try
{
var data = (string)parameters["documentContent"];
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(data);
// TODO: Тук може да се прочете Header-a на заявлението и да се определи типа на заявлението (DocumentTypeURI)
// Използвайки УРИ-то във валидацията още тук ще се връща съобщение, че не се потвърждава.
// Ако няма Header ще се използва Namespace-a.
string rootNamespaceURI = xmlDocument.DocumentElement.NamespaceURI;
string documentName = xmlDocument.DocumentElement.Name;
Regex rx = new Regex(@"[\d|\w]{1,4}-\d{4,6}$$");
string documentUri = rx.Match(rootNamespaceURI).ToString();
//string documentUri = "0009-000146";
string codeBase = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase;
UriBuilder uri = new UriBuilder(codeBase);//remove "File:" prefix
string uriPath = Uri.UnescapeDataString(uri.Path);
string path = Path.GetDirectoryName(uriPath);
string documentNamePrefix = documentUri.Length > 0 ? documentUri + "_" : "";
string documentFileName = documentNamePrefix + documentName + ".xsd";
//Uri documentXMLUri = new Uri(ConfigurationManager.AppSettings["XSDDirectoryPath"].ToString() + documentFileName);
Uri documentXMLUri = new Uri(path + "\\" + documentFileName);
EservicesXmlResolver xmlResolver = new EservicesXmlResolver();
using (var reader = new XmlTextReader((StringReader)xmlResolver.GetEntity(documentXMLUri, null, null)))
{
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.XmlResolver = xmlResolver;
schemaSet.Add(rootNamespaceURI, reader);
schemaSet.Compile();
xmlDocument.Schemas.Add(schemaSet);
xmlDocument.Validate(null);
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (XmlException)
{
throw new HttpResponseException(
this.Request.CreateResponse(
HttpStatusCode.OK,
new ODataError
{
Message = "0006-000069: Невалидна структура на обекта съгласно XML дефиницията му, вписана в регистъра на информационните обекти.",
MessageLanguage = "bg-BG",
ErrorCode = "0006-000069"
}
)
);
}
catch (XmlSchemaValidationException)
{
throw new HttpResponseException(
this.Request.CreateResponse(
HttpStatusCode.OK,
new ODataError
{
Message = "0006-000069: Невалидна структура на обекта съгласно XML дефиницията му, вписана в регистъра на информационните обекти.",
MessageLanguage = "bg-BG",
ErrorCode = "0006-000069"
}
)
);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public ITestActionResult BoundAction(int key, [FromBody] ODataActionParameters parameters)
{
VerifyActionParameters(parameters);
return(Ok(true));
}
public string Rate(ODataActionParameters parameters)
{
var ss = "mimi";
return(ss);
}
/// <summary>
/// Handles a POST request to an action.
/// </summary>
/// <param name="parameters">Parameters from action request content.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The task object that contains the action result.</returns>
public async Task <HttpResponseMessage> PostAction(
ODataActionParameters parameters, CancellationToken cancellationToken)
{
var path = GetPath();
var lastSegment = path.Segments.LastOrDefault();
if (lastSegment == null)
{
throw new InvalidOperationException(Resources.ControllerRequiresPath);
}
IQueryable result = null;
Func <string, object> getParaValueFunc = p =>
{
if (parameters == null)
{
return(null);
}
return(parameters[p]);
};
var segment = lastSegment as OperationImportSegment;
if (segment != null)
{
var unboundSegment = segment;
var operation = unboundSegment.OperationImports.FirstOrDefault();
result = await ExecuteOperationAsync(getParaValueFunc, operation.Name, false, null, cancellationToken).ConfigureAwait(false);
}
else
{
// Get queryable path builder to builder
var queryable = GetQuery(path);
if (queryable == null)
{
throw new HttpResponseException(
Request.CreateErrorResponse(
HttpStatusCode.NotFound,
Resources.ResourceNotFound));
}
if (lastSegment is OperationSegment)
{
var operationSegment = lastSegment as OperationSegment;
var operation = operationSegment.Operations.FirstOrDefault();
var queryResult = await ExecuteQuery(queryable, cancellationToken).ConfigureAwait(false);
result = await ExecuteOperationAsync(getParaValueFunc, operation.Name, false, queryResult, cancellationToken).ConfigureAwait(false);
}
}
if (path.EdmType == null)
{
// This is a void action, return 204 directly
return(Request.CreateResponse(HttpStatusCode.NoContent));
}
return(CreateQueryResponse(result, path.EdmType, null));
}
public IHttpActionResult PunchIn(ODataActionParameters parameters)
{
var taskId = (int)parameters["TaskId"];
var timezone = (string)parameters["InAtTimeZone"];
var latitudeForInAt = (string)parameters["LatitudeForInAt"];
var longitudeForInAt = (string)parameters["LongitudeForInAt"];
var sourceHardware = (string)parameters["SourceHardware"];
var sourceHostname = HttpContext.Current.Request.UserHostName;
var sourceIpAddress = HttpContext.Current.Request.UserHostAddress;
var sourceOperatingSystem = (string)parameters["SourceOperatingSystem"];
var sourceOperatingSystemVersion = (string)parameters["SourceOperatingSystemVersion"];
var sourceBrowser = (string)parameters["SourceBrowser"];
var sourceBrowserVersion = (string)parameters["SourceBrowserVersion"];
var currentUser = CurrentUser();
var task = db.Tasks
.Include(t => t.Job.Customer)
.Where(t => t.Id == taskId)
.FirstOrDefault();
// Ensure task belongs to the same organization.
if (currentUser.OrganizationId != task.Job.Customer.OrganizationId)
{
return(BadRequest());
}
// Ensure job is open.
if (task.Job.Status != "Open")
{
return(BadRequest());
}
// Prevent double submission.
var submission = cache.Get($"submission.punchin.{currentUser.Id}") as bool?;
if (submission.HasValue)
{
return(BadRequest("Cannot punch in twice within 5 seconds."));
}
try
{
var punch = repo.PunchIn(
taskId,
CurrentUser(),
"",
timezone,
latitudeForInAt,
longitudeForInAt,
sourceHardware,
sourceHostname,
sourceIpAddress,
sourceOperatingSystem,
sourceOperatingSystemVersion,
sourceBrowser,
sourceBrowserVersion);
// Record the submission.
var policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTime.UtcNow.AddSeconds(5);
cache.Set($"submission.punchin.{currentUser.Id}", true, policy);
return(Created(punch));
}
catch (DbEntityValidationException e)
{
string message = "";
foreach (var eve in e.EntityValidationErrors)
{
foreach (var ve in eve.ValidationErrors)
{
message += string.Format("{0} has error '{1}'; ", ve.PropertyName, ve.ErrorMessage);
}
}
return(Content(HttpStatusCode.BadRequest, message));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, ex.Message));
}
}
public IHttpActionResult PopulateRates(ODataActionParameters parameters)
{
telemetryClient.TrackEvent("Populate:Requested");
using (var transaction = db.Database.BeginTransaction())
{
try
{
var populateOptions = parameters["Options"] as PopulateRateOptions;
var currentUser = CurrentUser();
var nowUtc = DateTime.UtcNow;
var inAt = new DateTime(populateOptions.InAt.Year, populateOptions.InAt.Month, populateOptions.InAt.Day, 0, 0, 0, 0, DateTimeKind.Unspecified);
var outAt = new DateTime(populateOptions.OutAt.Year, populateOptions.OutAt.Month, populateOptions.OutAt.Day, 23, 59, 0, 0, DateTimeKind.Unspecified);
populateOptions.InAt = inAt;
populateOptions.OutAt = outAt;
int[] userIds = db.Users
.Where(u => u.OrganizationId == currentUser.OrganizationId)
.Select(u => u.Id)
.ToArray();
var originalPunchesTracked = db.Punches
.Where(p => userIds.Contains(p.UserId))
.Where(p => p.OutAt.HasValue)
.Where(p => DbFunctions.TruncateTime(p.InAt) >= inAt.Date)
.Where(p => DbFunctions.TruncateTime(p.InAt) <= outAt.Date)
.Where(p => !p.CommitId.HasValue); // Only unlocked punches
var originalPunchesNotTracked = originalPunchesTracked
.AsNoTracking() // Will be manipulated in memory
.ToList();
telemetryClient.TrackEvent("Populate:Starting", new Dictionary <string, string>()
{
{ "InAt", inAt.ToString("G") },
{ "OutAt", outAt.ToString("G") },
{ "UserId", currentUser.Id.ToString() },
{ "OrganizationId", currentUser.OrganizationId.ToString() }
});
// Save what the punches looked like before.
var before = originalPunchesNotTracked;
var populatedPunches = new PunchService().Populate(populateOptions, originalPunchesNotTracked, currentUser);
// Save what the punches look like after.
var after = populatedPunches;
// Delete the old punches and save the new ones.
db.Punches.RemoveRange(originalPunchesTracked);
db.SaveChanges();
db.Punches.AddRange(populatedPunches);
db.SaveChanges();
try
{
// Attempt to save the backup of the punches on Azure.
var backup = new
{
Before = before,
After = after
};
var json = JsonConvert.SerializeObject(backup);
// Prepare to upload the backup.
var azureConnectionString = ConfigurationManager.AppSettings["PunchBackupsAzureStorageConnectionString"].ToString();
BlobServiceClient blobServiceClient = new BlobServiceClient(azureConnectionString);
BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient("populate-punch-backups");
BlobClient blobClient = containerClient.GetBlobClient($"{currentUser.OrganizationId}/{nowUtc.Ticks}.json");
// Perform the upload.
using (var stream = new MemoryStream(Encoding.Default.GetBytes(json), false))
{
blobClient.Upload(stream);
}
}
catch (Exception ex)
{
telemetryClient.TrackException(ex);
}
telemetryClient.TrackEvent("Populate:Succeeded");
telemetryClient.Flush();
transaction.Commit();
return(Ok());
}
catch (Exception ex)
{
telemetryClient.TrackEvent("Populate:Failed");
telemetryClient.TrackException(ex);
telemetryClient.Flush();
transaction.Rollback();
return(BadRequest(ex.ToString()));
}
}
}
public void UpgradedAllOnCollectionOfVipCustomer(ODataActionParameters parameters)
{
}
public async Task<IHttpActionResult> Cancel([FromODataUri] String key, ODataActionParameters parameters)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanCancel");
if (!identity.Permissions.Contains(permissionId))
{
return StatusCode(HttpStatusCode.Forbidden);
}
var entityUri = new Uri(key);
var entity = LoadEntity(new DefaultAuthenticationProvider(), entityUri);
var lifeCycleManager = new LifeCycleManager(new DefaultAuthenticationProvider(), ExtractTypeFromUriString(key));
lifeCycleManager.Cancel(entityUri, entity, identity.Tid);
return Ok();
}
catch (UriFormatException e)
{
return BadRequest("Invalid id (Id should be a valid URI)");
}
catch (HttpRequestException e)
{
return BadRequest("Loading entity from passed Uri failed (Either not found or not authorized)");
}
catch (InvalidOperationException e)
{
return BadRequest("Changing state with 'Cancel' condition not possible");
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public IActionResult BoundAction(int key, ODataActionParameters parameters)
{
return(Ok($"BoundAction of Customers with key {key} : {System.Text.Json.JsonSerializer.Serialize(parameters)}"));
}
public void IsVipUpgraded(ODataActionParameters parameters, string param)
{
}
public IHttpActionResult ManageAttributes(int key, ODataActionParameters parameters)
{
var entity = GetExpandedEntity(key, x => x.ProductVariantAttributes.Select(y => y.ProductAttribute));
var result = new List <ProductVariantAttributeValue>();
this.ProcessEntity(() =>
{
var synchronize = parameters.GetValueSafe <bool>("Synchronize");
var data = (parameters["Attributes"] as IEnumerable <ManageAttributeType>)
.Where(x => x.Name.HasValue())
.ToList();
var attributeNames = new HashSet <string>(data.Select(x => x.Name), StringComparer.OrdinalIgnoreCase);
var pagedAttributes = _productAttributeService.Value.GetAllProductAttributes(0, 1);
var attributesData = pagedAttributes.SourceQuery
.Where(x => attributeNames.Contains(x.Name))
.Select(x => new { x.Id, x.Name })
.ToList();
var allAttributesDic = attributesData.ToDictionarySafe(x => x.Name, x => x, StringComparer.OrdinalIgnoreCase);
foreach (var srcAttr in data)
{
// Product attribute.
var attributeId = 0;
if (allAttributesDic.TryGetValue(srcAttr.Name, out var attributeData))
{
attributeId = attributeData.Id;
}
else
{
var attribute = new ProductAttribute {
Name = srcAttr.Name
};
_productAttributeService.Value.InsertProductAttribute(attribute);
attributeId = attribute.Id;
}
// Product attribute mapping.
var productAttribute = entity.ProductVariantAttributes.FirstOrDefault(x => x.ProductAttribute?.Name.IsCaseInsensitiveEqual(srcAttr.Name) ?? false);
if (productAttribute == null)
{
// No mapping to attribute yet.
productAttribute = new ProductVariantAttribute
{
ProductId = entity.Id,
ProductAttributeId = attributeId,
AttributeControlTypeId = srcAttr.ControlTypeId,
DisplayOrder = entity.ProductVariantAttributes.OrderByDescending(x => x.DisplayOrder).Select(x => x.DisplayOrder).FirstOrDefault() + 1,
IsRequired = srcAttr.IsRequired
};
entity.ProductVariantAttributes.Add(productAttribute);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
// Has already an attribute mapping.
if (srcAttr.Values.Count <= 0 && productAttribute.ShouldHaveValues())
{
_productAttributeService.Value.DeleteProductVariantAttribute(productAttribute);
}
else
{
productAttribute.AttributeControlTypeId = srcAttr.ControlTypeId;
productAttribute.IsRequired = srcAttr.IsRequired;
Service.UpdateProduct(entity);
}
}
// Values.
var maxDisplayOrder = productAttribute.ProductVariantAttributeValues
.OrderByDescending(x => x.DisplayOrder)
.Select(x => x.DisplayOrder)
.FirstOrDefault();
foreach (var srcVal in srcAttr.Values.Where(x => x.Name.HasValue()))
{
var value = productAttribute.ProductVariantAttributeValues.FirstOrDefault(x => x.Name.IsCaseInsensitiveEqual(srcVal.Name));
if (value == null)
{
value = new ProductVariantAttributeValue
{
ProductVariantAttributeId = productAttribute.Id,
Name = srcVal.Name,
Alias = srcVal.Alias,
Color = srcVal.Color,
PriceAdjustment = srcVal.PriceAdjustment,
WeightAdjustment = srcVal.WeightAdjustment,
IsPreSelected = srcVal.IsPreSelected,
DisplayOrder = ++maxDisplayOrder
};
productAttribute.ProductVariantAttributeValues.Add(value);
Service.UpdateProduct(entity);
}
else if (synchronize)
{
value.Alias = srcVal.Alias;
value.Color = srcVal.Color;
value.PriceAdjustment = srcVal.PriceAdjustment;
value.WeightAdjustment = srcVal.WeightAdjustment;
value.IsPreSelected = srcVal.IsPreSelected;
Service.UpdateProduct(entity);
}
}
if (synchronize)
{
foreach (var dstVal in productAttribute.ProductVariantAttributeValues.ToList())
{
if (!srcAttr.Values.Any(x => x.Name.IsCaseInsensitiveEqual(dstVal.Name)))
{
_productAttributeService.Value.DeleteProductVariantAttributeValue(dstVal);
}
}
}
}
});
return(Ok(entity.ProductVariantAttributes.AsQueryable()));
}
public IHttpActionResult BoundAction(int key, ODataActionParameters parameters)
{
VerifyActionParameters(parameters);
return Ok(true);
}
public IHttpActionResult Create(ODataActionParameters parameters)
{
if (parameters["dto"] == null)
{
throw new Exception("输入参数错误");
}
var dto = parameters["dto"] as QuestionCreateInputDto;
this.Validate(dto);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var questionEntity = dto.MapToEntity();
questionEntity.CreatedBy = User.Identity.Name;
foreach (var item in dto.Answers)
{
questionEntity.Answers.Add(new Answer {
Text = item, CreatedBy = User.Identity.Name
});
}
using (var transaction = Db.Database.BeginTransaction())
{
try
{
var contentEntity = questionEntity.MapToContent();
Db.Content.Add(contentEntity);
Db.SaveChanges();
questionEntity.Id = contentEntity.Id;
Db.Question.Add(questionEntity);
foreach (var t in dto.Tags)
{
var tag = new Tag
{
ContentId = questionEntity.Id,
ContentType = ContentTypeEnum.Question.ToString(),
Value = t
};
Db.Tag.Add(tag);
}
Db.SaveChanges();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
throw ex;
}
}
return(Created(questionEntity));
}
public System.Web.OData.PageResult <SampleDataModel.StoreDayHours> GetStoreDaysByStore(ODataActionParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var runtime = CommerceRuntimeManager.CreateRuntime(this.CommercePrincipal);
QueryResultSettings queryResultSettings = QueryResultSettings.SingleRecord;
queryResultSettings.Paging = new PagingInfo(10);
var request = new GetStoreHoursDataRequest((string)parameters["StoreNumber"])
{
QueryResultSettings = queryResultSettings
};
PagedResult <SampleDataModel.StoreDayHours> hours = runtime.Execute <GetStoreHoursDataResponse>(request, null).DayHours;
return(this.ProcessPagedResults(hours));
}
public void IsVipUpgraded(int key, ODataActionParameters parameters)
{
}
public void IsBaseAllUpgraded(ODataActionParameters parameters)
{
}
public async Task <IHttpActionResult> SavemdInternalStakeHolders([FromODataUri] int key, ODataActionParameters parameters)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok());
}
public void IsAllCustomersUpgraded(ODataActionParameters parameters)
{
}
public GeographyPoint LocationSwipe([FromODataUri] int key, ODataActionParameters parameters)
{
var loc = (GeographyPoint)parameters["Loc"] ?? null;
return(GeographyPoint.Create(loc.Longitude, loc.Latitude));
}
public void UpgradedAllOnCustomer(int key, ODataActionParameters parameters)
{
}
public override async Task <object> ReadAsync(ODataMessageReader messageReader, Type type, ODataDeserializerContext readContext)
{
if (messageReader == null)
{
throw Error.ArgumentNull("messageReader");
}
IEdmAction action = GetAction(readContext);
Contract.Assert(action != null);
// Create the correct resource type;
Dictionary <string, object> payload;
if (type == typeof(ODataActionParameters))
{
payload = new ODataActionParameters();
}
else
{
payload = new ODataUntypedActionParameters(action);
}
ODataParameterReader reader = await messageReader.CreateODataParameterReaderAsync(action).ConfigureAwait(false);
while (await reader.ReadAsync().ConfigureAwait(false))
{
string parameterName = null;
IEdmOperationParameter parameter = null;
switch (reader.State)
{
case ODataParameterReaderState.Value:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
if (parameter.Type.IsPrimitive())
{
payload[parameterName] = reader.Value;
}
else
{
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext);
}
break;
case ODataParameterReaderState.Collection:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
// ODataLib protects against this but asserting just in case.
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(collectionType != null);
ODataCollectionValue value = await ODataCollectionDeserializer
.ReadCollectionAsync(reader.CreateCollectionReader()).ConfigureAwait(false);
ODataCollectionDeserializer collectionDeserializer = (ODataCollectionDeserializer)DeserializerProvider.GetEdmTypeDeserializer(collectionType);
payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext);
break;
case ODataParameterReaderState.Resource:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
Contract.Assert(parameter.Type.IsStructured());
ODataReader resourceReader = reader.CreateResourceReader();
object item = await resourceReader.ReadResourceOrResourceSetAsync().ConfigureAwait(false);
ODataResourceDeserializer resourceDeserializer = (ODataResourceDeserializer)DeserializerProvider.GetEdmTypeDeserializer(parameter.Type);
payload[parameterName] = resourceDeserializer.ReadInline(item, parameter.Type, readContext);
break;
case ODataParameterReaderState.ResourceSet:
parameterName = reader.Name;
parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName);
Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName));
IEdmCollectionTypeReference resourceSetType = parameter.Type as IEdmCollectionTypeReference;
Contract.Assert(resourceSetType != null);
ODataReader resourceSetReader = reader.CreateResourceSetReader();
object feed = await resourceSetReader.ReadResourceOrResourceSetAsync().ConfigureAwait(false);
ODataResourceSetDeserializer resourceSetDeserializer = (ODataResourceSetDeserializer)DeserializerProvider.GetEdmTypeDeserializer(resourceSetType);
object result = resourceSetDeserializer.ReadInline(feed, resourceSetType, readContext);
IEdmTypeReference elementTypeReference = resourceSetType.ElementType();
Contract.Assert(elementTypeReference.IsStructured());
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
if (readContext.IsNoClrType)
{
payload[parameterName] = enumerable.ConvertToEdmObject(resourceSetType);
}
else
{
Type elementClrType = readContext.Model.GetClrType(elementTypeReference);
IEnumerable castedResult =
_castMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new[] { result }) as IEnumerable;
payload[parameterName] = castedResult;
}
}
break;
}
}
return(payload);
}
public IHttpActionResult PunchOut(ODataActionParameters parameters)
{
var timezone = (string)parameters["OutAtTimeZone"];
var latitudeForOutAt = (string)parameters["LatitudeForOutAt"];
var longitudeForOutAt = (string)parameters["LongitudeForOutAt"];
var sourceHardware = (string)parameters["SourceHardware"];
var sourceHostname = HttpContext.Current.Request.UserHostName;
var sourceIpAddress = HttpContext.Current.Request.UserHostAddress;
var sourceOperatingSystem = (string)parameters["SourceOperatingSystem"];
var sourceOperatingSystemVersion = (string)parameters["SourceOperatingSystemVersion"];
var sourceBrowser = (string)parameters["SourceBrowser"];
var sourceBrowserVersion = (string)parameters["SourceBrowserVersion"];
var currentUser = CurrentUser();
// Prevent double submission.
var submission = cache.Get($"submission.punchout.{currentUser.Id}") as bool?;
if (submission.HasValue)
{
return(BadRequest("Cannot punch out twice within 5 seconds."));
}
try
{
var punch = repo.PunchOut(
currentUser,
"",
timezone,
latitudeForOutAt,
longitudeForOutAt,
sourceHardware,
sourceHostname,
sourceIpAddress,
sourceOperatingSystem,
sourceOperatingSystemVersion,
sourceBrowser,
sourceBrowserVersion);
// Record the submission.
var policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTime.UtcNow.AddSeconds(5);
cache.Set($"submission.punchout.{currentUser.Id}", true, policy);
return(Created(punch));
}
catch (DbEntityValidationException e)
{
string message = "";
foreach (var eve in e.EntityValidationErrors)
{
foreach (var ve in eve.ValidationErrors)
{
message += string.Format("{0} has error '{1}'; ", ve.PropertyName, ve.ErrorMessage);
}
}
return(Content(HttpStatusCode.BadRequest, message));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, ex.Message));
}
}
public List<Product> PostArray(ODataActionParameters parameters)
{
var productDtos = parameters["products"] as IEnumerable<ProductDto>;
var newProducts = new List<Product>();
if (productDtos != null && productDtos.Any())
{
foreach (var productDto in productDtos)
{
var product = new Product
{
Id = Data.Values.Max(existingProduct => existingProduct.Id) + 1,
Name = productDto.Name,
Price = productDto.Price,
EnumValue = productDto.EnumValue
};
newProducts.Add(product);
Data.TryAdd(product.Id, product);
}
}
return newProducts;
}
public IQueryable <OrderItem> Get(ODataActionParameters parameters)
{
return(db.OrderItems);
}
public bool DoSomething(int key, ODataActionParameters parameters)
{
Assert.Equal(1, key);
Assert.Equal(1, parameters["p1"]);
ValidateAddress(parameters["p2"] as ODataActionTests.Address);
ValidateNumbers(parameters["p3"] as IList<string>);
ValidateAddresses(parameters["p4"] as IList<ODataActionTests.Address>);
return true;
}
public IHttpActionResult ListAc(ODataActionParameters parameters)
{
Vedio v = _db.Vedio.First();
return(Ok(23));
}
public async Task<IHttpActionResult> Decline([FromODataUri] String token, ODataActionParameters parameters)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanDecline");
if (!identity.Permissions.Contains(permissionId))
{
return StatusCode(HttpStatusCode.Forbidden);
}
var job = _coreService.Jobs.Where(j => token == j.Token &&
CALLOUT_JOB_TYPE == j.Type &&
j.State == JobStateEnum.Running.ToString())
.SingleOrDefault();
if (null == job)
{
return StatusCode(HttpStatusCode.NotFound);
}
var calloutDefinition = JsonConvert.DeserializeObject<CalloutData>(job.Parameters);
var lifeCycleManager = new LifeCycleManager(new DefaultAuthenticationProvider(), calloutDefinition.EntityType);
lifeCycleManager.OnDeclineCallback(job);
return Ok();
}
catch (InvalidOperationException e)
{
return BadRequest(String.Format("Decline job with token: '{0} not possible", token));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public bool CNSAction(int key, ODataActionParameters parameters)
{
return(true);
}
private static void VerifyActionParameters(ODataActionParameters parameters)
{
Assert.True(parameters.ContainsKey("modifiedDate"));
Assert.True(parameters.ContainsKey("modifiedTime"));
Assert.True(parameters.ContainsKey("nullableModifiedDate"));
Assert.True(parameters.ContainsKey("nullableModifiedTime"));
Assert.True(parameters.ContainsKey("dates"));
Assert.Equal(new Date(2015, 3, 1), parameters["modifiedDate"]);
Assert.Equal(new TimeOfDay(1, 5, 6, 8), parameters["modifiedTime"]);
Assert.Null(parameters["nullableModifiedDate"]);
Assert.Null(parameters["nullableModifiedTime"]);
IEnumerable<Date> dates = parameters["dates"] as IEnumerable<Date>;
Assert.NotNull(dates);
Assert.Equal(2, dates.Count());
}
public IHttpActionResult Acao([FromODataUri] int key, ODataActionParameters parameters)
{
int rating = (int)parameters["Rating"];
return(Ok());
}
public IHttpActionResult UnboundAction(ODataActionParameters parameters)
{
VerifyActionParameters(parameters);
return Ok(true);
}
public void IsBaseUpgraded(int key, CancellationToken cancellation, ODataActionParameters parameters)
{
}
