text:
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.

#include "BlueprintEditorPrivatePCH.h"

#include "BlueprintUtilities.h"
#include "BlueprintEditorUtils.h"
#include "GraphEditorDragDropAction.h"
#include "BPFunctionDragDropAction.h"
#include "BlueprintFunctionNodeSpawner.h"

#define LOCTEXT_NAMESPACE "FunctionDragDropAction"

/*******************************************************************************
* Static File Helpers
*******************************************************************************/

/**
 * A default for function node drag-drop operations to use if one wasn't
 * supplied. Checks to see if a function node is allowed to be placed where it
 * is currently dragged.
 *
 * @param  DropActionIn		The action that will be executed when the user drops the dragged item.
 * @param  HoveredGraphIn	A pointer to the graph that the user currently has the item dragged over.
 * @param  ImpededReasonOut	If this returns false, this will be filled out with a reason to present the user with.
 * @param  FunctionIn		The function that the associated node would be calling.
 * @return True is the dragged palette item can be dropped where it currently is, false if not.
 */
static bool CanFunctionBeDropped(TSharedPtr<FEdGraphSchemaAction> /*DropActionIn*/, UEdGraph* HoveredGraphIn, FText& ImpededReasonOut, UFunction const* FunctionIn)
{
	bool bCanBePlaced = true;
	if (HoveredGraphIn == NULL)
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("DropOnlyInGraph", "Nodes can only be placed inside the blueprint graph");
	}
	else if (!HoveredGraphIn->GetSchema()->IsA(UEdGraphSchema_K2::StaticClass()))
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("CannotCreateInThisSchema", "Cannot call functions in this type of graph");
	}
	else if (FunctionIn == NULL)
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("InvalidFuncAction", "Invalid function for placement");
	}
	else if ((HoveredGraphIn->GetSchema()->GetGraphType(HoveredGraphIn) == EGraphType::GT_Function) && FunctionIn->HasMetaData(FBlueprintMetadata::MD_Latent))
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("CannotCreateLatentInGraph", "Cannot call latent functions in function graphs");
	}

	return bCanBePlaced;
}

/**
 * Checks to see if a macro node is allowed to be placed where it is currently
 * dragged.
 *
 * @param  DropActionIn		The action that will be executed when the user drops the dragged item.
 * @param  HoveredGraphIn	A pointer to the graph that the user currently has the item dragged over.
 * @param  ImpededReasonOut	If this returns false, this will be filled out with a reason to present the user with.
 * @param  MacroGraph		The macro graph that the node would be executing.
 * @param  bInIsLatentMacro	True if the macro has latent functions in it
 * @return True is the dragged palette item can be dropped where it currently is, false if not.
 */
static bool CanMacroBeDropped(TSharedPtr<FEdGraphSchemaAction> /*DropActionIn*/, UEdGraph* HoveredGraphIn, FText& ImpededReasonOut, UEdGraph* MacroGraph, bool bIsLatentMacro)
{
	bool bCanBePlaced = true;
	if (HoveredGraphIn == NULL)
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("DropOnlyInGraph", "Nodes can only be placed inside the blueprint graph");
	}
	else if (!HoveredGraphIn->GetSchema()->IsA(UEdGraphSchema_K2::StaticClass()))
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("CannotCreateInThisSchema_Macro", "Cannot call macros in this type of graph");
	}
	else if (MacroGraph == HoveredGraphIn)
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("CannotRecurseMacro", "Cannot place a macro instance in its own graph");
	}
	else if( bIsLatentMacro && HoveredGraphIn->GetSchema()->GetGraphType(HoveredGraphIn) == GT_Function)
	{
		bCanBePlaced = false;
		ImpededReasonOut = LOCTEXT("CannotPlaceLatentMacros", "Cannot place a macro instance with latent functions in function graphs!");
	}

	return bCanBePlaced;
}

/*******************************************************************************
* FKismetDragDropAction
*******************************************************************************/

//------------------------------------------------------------------------------
void FKismetDragDropAction::HoverTargetChanged()
{
	UEdGraph* HoveredGraph = GetHoveredGraph();

	FText CannotDropReason = FText::GetEmpty();
	if (ActionWillShowExistingNode())
	{
		FSlateBrush const* ShowsExistingIcon = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.ShowNode"));
		FText DragingText = FText::Format(LOCTEXT("ShowExistingNode", "Show '{0}'"), ActionNode->MenuDescription);
		SetSimpleFeedbackMessage(ShowsExistingIcon, FLinearColor::White, DragingText);
	}
	// it should be obvious that we can't drop on anything but a graph, so no need to point that out
	else if ((HoveredGraph == NULL) || !CanBeDroppedDelegate.IsBound() || CanBeDroppedDelegate.Execute(ActionNode, HoveredGraph, CannotDropReason))
	{
		FGraphSchemaActionDragDropAction::HoverTargetChanged();
	}
	else
	{
		FSlateBrush const* DropPreventedIcon = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
		SetSimpleFeedbackMessage(DropPreventedIcon, FLinearColor::White, CannotDropReason);
	}
}

//------------------------------------------------------------------------------
FReply FKismetDragDropAction::DroppedOnPanel( const TSharedRef< SWidget >& Panel, FVector2D ScreenPosition, FVector2D GraphPosition, UEdGraph& Graph)
{
	FReply Reply = FReply::Unhandled();

	FText CannotDropReason = FText::GetEmpty();
	if (!CanBeDroppedDelegate.IsBound() || CanBeDroppedDelegate.Execute(ActionNode, GetHoveredGraph(), CannotDropReason))
	{
		Reply = FGraphSchemaActionDragDropAction::DroppedOnPanel(Panel, ScreenPosition, GraphPosition, Graph);
	}

	if (Reply.IsEventHandled())
	{
		AnalyticCallback.ExecuteIfBound();
	}

	return Reply;
}

//------------------------------------------------------------------------------
bool FKismetDragDropAction::ActionWillShowExistingNode() const
{
	bool bWillFocusOnExistingNode = false;

	UEdGraph* HoveredGraph = GetHoveredGraph();
	if (ActionNode.IsValid() && (HoveredGraph != NULL))
	{
		bWillFocusOnExistingNode = (ActionNode->GetTypeId() == FEdGraphSchemaAction_K2TargetNode::StaticGetTypeId()) ||
			(ActionNode->GetTypeId() == FEdGraphSchemaAction_K2InputAction::StaticGetTypeId());

		if (!bWillFocusOnExistingNode)
		{
			if (ActionNode->GetTypeId() == FEdGraphSchemaAction_K2AddEvent::StaticGetTypeId())
			{
				FEdGraphSchemaAction_K2AddEvent* AddEventAction = (FEdGraphSchemaAction_K2AddEvent*)ActionNode.Get();
				bWillFocusOnExistingNode = AddEventAction->EventHasAlreadyBeenPlaced(FBlueprintEditorUtils::FindBlueprintForGraph(HoveredGraph));
			}
			else if (ActionNode->GetTypeId() == FEdGraphSchemaAction_K2Event::StaticGetTypeId())
			{
				FEdGraphSchemaAction_K2Event* FuncAction = (FEdGraphSchemaAction_K2Event*)ActionNode.Get();
				UK2Node_CustomEvent* CustomEvent = Cast<UK2Node_CustomEvent>(FuncAction->NodeTemplate);
				// Drag and dropping custom event's will place a Call Function and will not focus the existing event
				if (CustomEvent == nullptr)
				{
					bWillFocusOnExistingNode = true;
				}
			}
		}
	}

	return bWillFocusOnExistingNode;
}

/*******************************************************************************
* FKismetFunctionDragDropAction
*******************************************************************************/

//------------------------------------------------------------------------------
TSharedRef<FKismetFunctionDragDropAction> FKismetFunctionDragDropAction::New(
	TSharedPtr<FEdGraphSchemaAction>	InActionNode,
	FName								InFunctionName,
	UClass*								InOwningClass,
	FMemberReference const&				InCallOnMember,
	FNodeCreationAnalytic				AnalyticCallback,
	FCanBeDroppedDelegate				CanBeDroppedDelegate /* = FCanBeDroppedDelegate() */)
{
	TSharedRef<FKismetFunctionDragDropAction> Operation = MakeShareable(new FKismetFunctionDragDropAction);
	Operation->FunctionName     = InFunctionName;
	Operation->OwningClass      = InOwningClass;
	Operation->CallOnMember     = InCallOnMember;
	Operation->AnalyticCallback = AnalyticCallback;
	Operation->CanBeDroppedDelegate = CanBeDroppedDelegate;
	Operation->ActionNode = InActionNode;

	if (!CanBeDroppedDelegate.IsBound())
	{
		Operation->CanBeDroppedDelegate = FCanBeDroppedDelegate::CreateStatic(&CanFunctionBeDropped, Operation->GetFunctionProperty());
	}

	Operation->Construct();
	return Operation;
}

//------------------------------------------------------------------------------
FKismetFunctionDragDropAction::FKismetFunctionDragDropAction()
	: OwningClass(NULL)
{

}

//------------------------------------------------------------------------------
void FKismetFunctionDragDropAction::HoverTargetChanged()
{
	FKismetDragDropAction::HoverTargetChanged();
}

//------------------------------------------------------------------------------
FReply FKismetFunctionDragDropAction::DroppedOnPanel(TSharedRef<SWidget> const& Panel, FVector2D ScreenPosition, FVector2D GraphPosition, UEdGraph& Graph)
{
	FReply Reply = FReply::Unhandled();

	// The ActionNode set during construction points to the Graph, this is suitable for displaying the mouse decorator but needs to be more complete based on the current graph
	UBlueprintFunctionNodeSpawner* FunctionNodeSpawner = nullptr;
	FunctionNodeSpawner = GetDropAction(Graph);

	if (FunctionNodeSpawner)
	{
		FText CannotDropReason = FText::GetEmpty();
		if (!CanBeDroppedDelegate.IsBound() || CanBeDroppedDelegate.Execute(nullptr, GetHoveredGraph(), CannotDropReason))
		{
			UFunction const* Function = GetFunctionProperty();
			if ((Function != NULL) && UEdGraphSchema_K2::CanUserKismetCallFunction(Function))
			{
				AnalyticCallback.ExecuteIfBound();

				IBlueprintNodeBinder::FBindingSet Bindings;
				FunctionNodeSpawner->Invoke(&Graph, Bindings, GraphPosition);

				Reply = FReply::Handled();
			}
		}
	}

	return Reply;
}

//------------------------------------------------------------------------------
UFunction const* FKismetFunctionDragDropAction::GetFunctionProperty() const
{
	check(OwningClass != NULL);
	check(FunctionName != NAME_None);

	UFunction* Function = FindField<UFunction>(OwningClass, FunctionName);
	return Function;
}

//------------------------------------------------------------------------------
UBlueprintFunctionNodeSpawner* FKismetFunctionDragDropAction::GetDropAction(UEdGraph& Graph) const
{
	if (UEdGraph const* const HoveredGraph = &Graph)
	{
		if (UBlueprint* DropOnBlueprint = FBlueprintEditorUtils::FindBlueprintForGraph(HoveredGraph))
		{
			// make temp list builder
			FGraphActionListBuilderBase TempListBuilder;
			TempListBuilder.OwnerOfTemporaries = NewObject<UEdGraph>(DropOnBlueprint);
			TempListBuilder.OwnerOfTemporaries->SetFlags(RF_Transient);

			UEdGraphSchema_K2 const* K2Schema = GetDefault<UEdGraphSchema_K2>();
			check(K2Schema != NULL);

			if (UFunction const* Function = GetFunctionProperty())
			{
				return UBlueprintFunctionNodeSpawner::Create(Function);
			}
		}
	}
	return nullptr;
}

/*******************************************************************************
* FKismetMacroDragDropAction
*******************************************************************************/

//------------------------------------------------------------------------------
TSharedRef<FKismetMacroDragDropAction> FKismetMacroDragDropAction::New(
	FName                 InMacroName,
	UBlueprint*           InBlueprint,
	UEdGraph*             InMacro,
	FNodeCreationAnalytic AnalyticCallback)
{
	TSharedRef<FKismetMacroDragDropAction> Operation = MakeShareable(new FKismetMacroDragDropAction);
	Operation->MacroName = InMacroName;
	Operation->Macro = InMacro;
	Operation->Blueprint = InBlueprint;
	Operation->AnalyticCallback = AnalyticCallback;

	// Check to see if the macro has any latent functions in it, some graph types do not allow for latent functions
	bool bIsLatentMacro = FBlueprintEditorUtils::CheckIfGraphHasLatentFunctions(Operation->Macro);

	Operation->CanBeDroppedDelegate = FCanBeDroppedDelegate::CreateStatic(&CanMacroBeDropped, InMacro, bIsLatentMacro);

	Operation->Construct();
	return Operation;
}

//------------------------------------------------------------------------------
FKismetMacroDragDropAction::FKismetMacroDragDropAction()
	: Macro(NULL)
{

}

//------------------------------------------------------------------------------
void FKismetMacroDragDropAction::HoverTargetChanged()
{
	UEdGraph* HoveredGraph = GetHoveredGraph();

	FText CannotDropReason = FText::GetEmpty();
	// it should be obvious that we can't drop on anything but a graph, so no need to point that out
	if ((HoveredGraph == NULL) || !CanBeDroppedDelegate.IsBound() || CanBeDroppedDelegate.Execute(ActionNode, HoveredGraph, CannotDropReason))
	{
		FSlateBrush const* DropPreventedIcon = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.NewNode"));
		SetSimpleFeedbackMessage(DropPreventedIcon, FLinearColor::White, FText::FromName(MacroName));
	}
	else
	{
		FSlateBrush const* DropPreventedIcon = FEditorStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error"));
		SetSimpleFeedbackMessage(DropPreventedIcon, FLinearColor::White, CannotDropReason);
	}
}

//------------------------------------------------------------------------------
FReply FKismetMacroDragDropAction::DroppedOnPanel(TSharedRef<SWidget> const& Panel, FVector2D ScreenPosition, FVector2D GraphPosition, UEdGraph& Graph)
{
	check(Macro);
	check(CanBeDroppedDelegate.IsBound());

	FReply Reply = FReply::Unhandled();

	FText CannotDropReason = FText::GetEmpty();
	if (CanBeDroppedDelegate.Execute(TSharedPtr<FEdGraphSchemaAction>(), &Graph, CannotDropReason))
	{
		UK2Node_MacroInstance* MacroTemplate = NewObject<UK2Node_MacroInstance>();
		MacroTemplate->SetMacroGraph(Macro);
		AnalyticCallback.ExecuteIfBound();

		FEdGraphSchemaAction_K2NewNode::SpawnNodeFromTemplate<UK2Node_MacroInstance>(&Graph, MacroTemplate, GraphPosition);
		Reply = FReply::Handled();
	}
	return Reply;
}

#undef LOCTEXT_NAMESPACE


text:
module GmoneyClient
  VERSION = "0.0.1"
end

redpajama_set_name: RedPajamaGithub


text:
from app import database_manager

print(database_manager.getAccountsInfo())


text:
from networking_plumgrid.neutron.plugins.common import constants as \
    net_pg_const
from networking_plumgrid.neutron.plugins.common import exceptions as plum_excep
from networking_plumgrid.neutron.plugins.common import \
    policy_exceptions as policy_exc
from oslo_log import log as logging
from oslo_utils import uuidutils

LOG = logging.getLogger(__name__)

def _retrieve_subnet_dict(self, port_db, context):
    """
    Helper function to retrieve the subnet dictionary
    """
    # Retrieve subnet information
    subnet_db = {}
    if len(port_db["fixed_ips"]) != 0:
        for subnet_index in range(0,
                                  len(port_db["fixed_ips"])):
            subnet_id = (port_db["fixed_ips"][subnet_index]
                         ["subnet_id"])
            subnet_db[subnet_index] = self._get_subnet(context, subnet_id)
    return subnet_db

def _check_floatingip_in_use(self, fp_id, ptag_db):
    """
    Helper function to check if Floating IP already exists and
    is associated with a SecurityGroup/PolicyTag
    """
    for entry in ptag_db:
        if fp_id == entry["floatingip_id"]:
            return True
    return False

def _check_floatingip_network(self, context, ptag_db):
    """
    Helper function to check Floating IP is from the specified
    External Network
    """
    floatingip_db = self.get_floatingip(context,
                                        ptag_db["policy_tag"]["floatingip_id"])
    router_db = self.get_routers(context,
                   filters={"tenant_id": [ptag_db["policy_tag"]["tenant_id"]]})
    floating_net_id = floatingip_db["floating_network_id"]

    if floatingip_db.get('port_id') is not None:
        raise policy_exc.FloatingIPAlreadyInUse(id=str(floatingip_db["id"]))

    external_gateway = []
    if "router_id" in ptag_db["policy_tag"] and \
       ptag_db["policy_tag"]["router_id"] is not None:
        external_gateway.append(ptag_db["policy_tag"]["router_id"])
    else:
        for router in router_db:
            if ("external_gateway_info" in router and
                router["external_gateway_info"] and
                router["external_gateway_info"]
                      ["network_id"] == floating_net_id):
                external_gateway.append(router["id"])
        if len(external_gateway) == 0:
            raise policy_exc.GatewayNotSet(id=str(floatingip_db["id"]))
        if len(external_gateway) > 1:
            raise policy_exc.MultipleExternalGatewaysFound(
                                           gateway_list=external_gateway)
    return (floatingip_db, external_gateway[0])

def _check_duplicate_ports_policy_service_create(self, ps_db):
    """
    Helper function to check if duplicate ingress, egress, bidirectional
    ports exists in create policy service JSON
    """
    port_list = []
    if "ingress_ports" in ps_db and ps_db["ingress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                         in ps_db["ingress_ports"]]))
        if _check_duplicate_ports_config(ps_db["ingress_ports"]):
            return True, "ingress ports"

    if "egress_ports" in ps_db and ps_db["egress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                         in ps_db["egress_ports"]]))
        if _check_duplicate_ports_config(ps_db["egress_ports"]):
            return True, "egress ports"

    if "bidirectional_ports" in ps_db and ps_db["bidirectional_ports"]:
        port_list.append(set([tuple(d.items()) for d
                         in ps_db["bidirectional_ports"]]))
        if _check_duplicate_ports_config(ps_db["bidirectional_ports"]):
            return True, "bidirectional ports"

    if _check_duplicate_ports_across_config(port_list):
        return True, "create parameters"

    return False, None

def _check_duplicate_ports_policy_service_update(self, ps_db):
    """
    Helper function to check if duplicate ingress, egress, bidirectional
    ports exists in update policy service JSON
    """
    port_list = []
    if "add_ingress_ports" in ps_db and ps_db["add_ingress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                         in ps_db["add_ingress_ports"]]))
        if _check_duplicate_ports_config(ps_db["add_ingress_ports"]):
            return True, "add ingress ports"

    if "add_egress_ports" in ps_db and ps_db["add_egress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                          in ps_db["add_egress_ports"]]))
        if _check_duplicate_ports_config(ps_db["add_egress_ports"]):
            return True, "add egress ports"

    if "add_bidirectional_ports" in ps_db and ps_db["add_bidirectional_ports"]:
        port_list.append(set([tuple(d.items()) for d
                          in ps_db["add_bidirectional_ports"]]))
        if _check_duplicate_ports_config(ps_db["add_bidirectional_ports"]):
            return True, "add bidirectional ports"

    if "remove_ingress_ports" in ps_db and ps_db["remove_ingress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                          in ps_db["remove_ingress_ports"]]))
        if _check_duplicate_ports_config(ps_db["remove_ingress_ports"]):
            return True, "remove ingress ports"

    if "remove_egress_ports" in ps_db and ps_db["remove_egress_ports"]:
        port_list.append(set([tuple(d.items()) for d
                          in ps_db["remove_egress_ports"]]))
        if _check_duplicate_ports_config(ps_db["remove_egress_ports"]):
            return True, "remove engress ports"

    if ("remove_bidirectional_ports" in ps_db
        and ps_db["remove_bidirectional_ports"]):
        port_list.append(set([tuple(d.items()) for d
                          in ps_db["remove_bidirectional_ports"]]))
        if _check_duplicate_ports_config(ps_db["remove_bidirectional_ports"]):
            return True, "remove bidirectional ports"

    if _check_duplicate_ports_across_config(port_list):
        return True, "update parameters"

    return False, None

def _check_duplicate_ports_config(port_db):
    if (len(port_db) > len([dict(t) for t in
        set([tuple(d.items()) for d in port_db])])):
        return True

def _check_duplicate_ports_across_config(list_port_db):
    for i in range(0, len(list_port_db)):
        for j in range(i + 1, len(list_port_db)):
            if (len(list_port_db[i].intersection(list_port_db[j])) > 0):
                return True

def _validate_port_owner(port_db):
    """
    Helper function to validate port is owned by a compute resource
    """
    if ("device_owner" in port_db and "binding:vif_type" in port_db and
        "compute" in port_db["device_owner"] and
        port_db["binding:vif_type"] == net_pg_const.BINDING_VIF_TYPE_IOVISOR):
        return True
    return False

def _check_policy_service_leg_mode(ps_obj, updated_ps_obj=None):
    """
    Helper function to check if bidirectional ports are
    specified with ingress or egress ports
    """
    if ("ingress_ports" in ps_obj and "egress_ports"
        in ps_obj and "bidirectional_ports" in ps_obj):
        if updated_ps_obj is None:
            if ((ps_obj["ingress_ports"] or ps_obj["egress_ports"])
                and ps_obj["bidirectional_ports"]):
                return True
        else:
            if ps_obj["ingress_ports"] or ps_obj["egress_ports"]:
                if ("add_bidirectional_ports" in updated_ps_obj or
                    "remove_bidirectional_ports" in updated_ps_obj):
                    return True
            elif ps_obj["bidirectional_ports"]:
                if ("add_ingress_ports" in updated_ps_obj or
                    "add_egress_ports" in updated_ps_obj or
                    "remove_ingress_ports" in updated_ps_obj or
                    "remove_egress_ports" in updated_ps_obj):
                    return True
            else:
                #Update call with any prior ports in policy service
                if ((("add_ingress_ports" in updated_ps_obj or
                      "add_ingress_ports" in updated_ps_obj)
                    or ("remove_ingress_ports" in updated_ps_obj or
                        "remove_egress_ports" in updated_ps_obj))
                    and ("add_bidirectional_ports" in updated_ps_obj or
                         "remove_bidirectional_ports" in updated_ps_obj)):
                    return True
    return False

def _is_security_group(context, ep_obj, ep_db, config):
    if config in ep_db and ep_db[config]:
        for epg in ep_db[config]:
            epg_id_list = ep_obj.get_endpoint_groups(context,
                                     filters={'id': [epg['id']]},
                                     fields=["id"])
            if len(epg_id_list) == 1:
                if ("is_security_group" in epg_id_list[0]
                    and epg_id_list[0]["is_security_group"]):
                    operation = "Endpoint association"
                    raise policy_exc.OperationNotAllowed(operation=operation,
                                                       id=epg_id_list[0]["id"])

def _validate_ep_config(ep_db):
    if ((ep_db["ip_mask"] and ep_db["ip_port"]) or
        (ep_db["ip_mask"]and ep_db["port_id"]) or
        (ep_db["ip_port"] and ep_db["port_id"])):
        raise policy_exc.MultipleAssociationForEndpoint()

def _check_duplicates_endpoint_config(ep_db):
    if "ep_groups" in ep_db and ep_db["ep_groups"]:
        if (len(ep_db["ep_groups"]) > len([dict(t) for t in
            set([tuple(d.items()) for d in ep_db["ep_groups"]])])):
            raise policy_exc.DuplicateEndpointGroup()
    if "add_endpoint_groups" in ep_db and ep_db["add_endpoint_groups"]:
        if (len(ep_db["add_endpoint_groups"]) > len([dict(t) for t in
            set([tuple(d.items()) for d in ep_db["add_endpoint_groups"]])])):
            raise policy_exc.DuplicateEndpointGroup()
    if "remove_endpoint_groups" in ep_db and ep_db["remove_endpoint_groups"]:
        if (len(ep_db["remove_endpoint_groups"]) > len([dict(t) for t in
            set([tuple(d.items()) for d in
            ep_db["remove_endpoint_groups"]])])):
            raise policy_exc.DuplicateEndpointGroup()

    if (("add_endpoint_groups" in ep_db and ep_db["add_endpoint_groups"]) and
        ("remove_endpoint_groups" in ep_db
         and ep_db["remove_endpoint_groups"])):
        if (len(set([tuple(d.items()) for d in ep_db["add_endpoint_groups"]]).
            intersection(set([tuple(d.items()) for d in
            ep_db["remove_endpoint_groups"]]))) > 0):
            raise policy_exc.DuplicateEndpointGroup()

def _process_policy_tag(self, context, epg_db):
    if "policy_tag_id" in epg_db and epg_db["policy_tag_id"]:
        if (not uuidutils.is_uuid_like(epg_db['policy_tag_id']) and
            epg_db['policy_tag_id'] is not None):
            ptag_list = self.get_policy_tags(context,
                                 filters={'name': [epg_db['policy_tag_id']]},
                                 fields=["id"])

            if len(ptag_list) == 1:
                epg_db['policy_tag_id'] = ptag_list[0]["id"]
            elif len(ptag_list) == 0:
                err_message = ("No policy tag"
                               " matches found for tag"
                               " '%s'" % epg_db['policy_tag_id'])
                raise plum_excep.PLUMgridException(err_msg=err_message)
            else:
                err_message = ("Multiple policy tag"
                               " matches found for tag"
                               " '%s', use an ID to be more"
                               " specific." % epg_db['policy_tag_id'])
                raise plum_excep.PLUMgridException(err_msg=err_message)
    return epg_db

def _process_epg_update(self, context, epg_db):
    ptag_db = {}
    if "policy_tag_id" in epg_db and epg_db["policy_tag_id"]:
        config = "policy_tag_id"
    elif "add_tag" in epg_db and epg_db["add_tag"]:
        config = "add_tag"
    elif "remove_tag" in epg_db and epg_db["remove_tag"]:
        config = "remove_tag"
    else:
        config = None
    if config in epg_db and epg_db[config]:
        if (not uuidutils.is_uuid_like(epg_db[config]) and
            epg_db[config] is not None):
            ptag_list = self.get_policy_tags(context,
                                 filters={'name': [epg_db[config]]},
                                 fields=["id"])

            if len(ptag_list) == 1:
                epg_db[config] = ptag_list[0]["id"]
                ptag_db = self.get_policy_tag(context,
                                              ptag_list[0]["id"])
            elif len(ptag_list) == 0:
                err_message = ("No policy tag"
                               " matches found for tag"
                               " '%s'" % epg_db[config])
                raise plum_excep.PLUMgridException(err_msg=err_message)
            else:
                err_message = ("Multiple policy tag"
                               " matches found for tag"
                               " '%s', use an ID to be more"
                               " specific." % epg_db[config])
                raise plum_excep.PLUMgridException(err_msg=err_message)
        elif (uuidutils.is_uuid_like(epg_db[config]) and
              epg_db[config] is not None):
            ptag_id = epg_db[config]
            ptag_db = self.get_policy_tag(context,
                                          ptag_id)
    return (epg_db, ptag_db)

def _check_policy_service_in_use(self, context, id):
    """
    Helper function to check policy service is in use by
    any policy rule
    """
    pr_list = self.get_policy_rules(context,
                              fields=["id", "action_target"])
    action_target_list = []
    for rule in pr_list:
        if _check_remote_action_target(rule):
            action_target_list.append((rule["action_target"].split(":"))[1])
        else:
            action_target_list.append(rule["action_target"])
    in_use_list = filter(lambda x: x == id, action_target_list)
    if len(in_use_list) > 0:
        raise policy_exc.PolicyServiceInUsePolicyRule(id=id)

def _recursive_delete_endpoints(self, context, id):
    """
    Helper function to delete endpoints when endpoint group
    is deleted
    """
    endpoint_list = self.get_endpoints(context,
                                       filters={'ep_groups': [{'id': id}]})
    for endpoint in endpoint_list:
        if ((len(endpoint["ep_groups"]) == 1) and
            endpoint["ep_groups"][0]["id"] == id):
            self.delete_endpoint(context, endpoint["id"])

def _check_remote_action_target(pr_db):
    """
    Helper function to check if action target for policy rule
    is for a tenant id
    """
    if "action_target" in pr_db and pr_db["action_target"]:
        action_target_db = pr_db["action_target"].split(":")
        if len(action_target_db) == 2:
            return True
        else:
            return False

def _update_port_description(port_db, port_data):
    """
    Helper function to update port description
    """
    if "description" in port_data:
        port_db["description"] = port_data["description"]


text:
#pragma once

#include <pangolin/video/iostream_operators.h>
#include <pangolin/utils/type_convert.h>

namespace pangolin
{

enum OpenNiSensorType
{
    OpenNiUnassigned = -1,
    OpenNiRgb = 0,
    OpenNiIr,
    OpenNiDepth_1mm,
    OpenNiDepth_1mm_Registered,
    OpenNiDepth_100um,
    OpenNiIr8bit,
    OpenNiIr24bit,
    OpenNiIrProj,
    OpenNiIr8bitProj,
    OpenNiGrey
};

struct PANGOLIN_EXPORT OpenNiStreamMode
{
    OpenNiStreamMode(
        OpenNiSensorType sensor_type=OpenNiUnassigned,
        ImageDim dim=ImageDim(640,480), ImageRoi roi=ImageRoi(0,0,0,0), int fps=30, int device=0
    )
        : sensor_type(sensor_type), dim(dim), roi(roi), fps(fps), device(device)
    {

    }

    OpenNiSensorType sensor_type;
    ImageDim dim;
    ImageRoi roi;
    int fps;
    int device;
};

inline OpenNiSensorType openni_sensor(const std::string& str)
{
    if( !str.compare("grey") || !str.compare("gray") ) {
        return OpenNiGrey;
    }else if( !str.compare("rgb") ) {
        return OpenNiRgb;
    }else if( !str.compare("ir") ) {
        return OpenNiIr;
    }else if( !str.compare("depth1mm") || !str.compare("depth") ) {
        return OpenNiDepth_1mm;
    }else if( !str.compare("depth100um") ) {
        return OpenNiDepth_100um;
    }else if( !str.compare("depth_reg") || !str.compare("reg_depth")) {
        return OpenNiDepth_1mm_Registered;
    }else if( !str.compare("ir8") ) {
        return OpenNiIr8bit;
    }else if( !str.compare("ir24") ) {
        return OpenNiIr24bit;
    }else if( !str.compare("ir+") ) {
        return OpenNiIrProj;
    }else if( !str.compare("ir8+") ) {
        return OpenNiIr8bitProj;
    }else if( str.empty() ) {
        return OpenNiUnassigned;
    }else{
        throw pangolin::VideoException("Unknown OpenNi sensor", str );
    }
}

// Find prefix character key
// Given arguments "depth!5:320x240@15", "!:@", would return map
// \0->"depth", !->"5", :->"320x240", @->"15"
inline std::map<char,std::string> GetTokenSplits(const std::string& str, const std::string& tokens)
{
    std::map<char,std::string> splits;

    char last_token = 0;
    size_t  last_start = 0;
    for(unsigned int i=0; i<str.size(); ++i) {
        size_t token_pos = tokens.find(str[i]);
        if(token_pos != std::string::npos) {
            splits[last_token] = str.substr(last_start, i-last_start);
            last_token = tokens[token_pos];
            last_start = i+1;
        }
    }

    if(last_start < str.size()) {
        splits[last_token] = str.substr(last_start);
    }

    return splits;
}

inline std::istream& operator>> (std::istream &is, OpenNiStreamMode& fmt)
{
    std::string str;
    is >> str;

    std::map<char,std::string> splits = GetTokenSplits(str, "!:@#");

    if(splits.count(0)) {
        fmt.sensor_type = openni_sensor(splits[0]);
    }

    if(splits.count('@')) {
        fmt.fps = pangolin::Convert<int,std::string>::Do(splits['@']);
    }

    if(splits.count(':')) {
        fmt.dim = pangolin::Convert<ImageDim,std::string>::Do(splits[':']);
    }

    if(splits.count('!')) {
        fmt.device = pangolin::Convert<int,std::string>::Do(splits['!']);
    }

    if(splits.count('#')) {
        fmt.roi = pangolin::Convert<ImageRoi,std::string>::Do(splits['#']);
    }

    return is;
}

}


text:
<?php

/**
 *
 * @package BLW\Core
 * @version GIT: 0.2.0
 * @author  Walter Otsyula <wotsyula@mast3rpee.tk>
 */
namespace BLW\Type;

// @codeCoverageIgnoreStart
if (! defined('BLW')) {

    if (strstr($_SERVER['PHP_SELF'], basename(__FILE__))) {
        header("$_SERVER[SERVER_PROTOCOL] 404 Not Found");
        header('Status: 404 Not Found');

        $_SERVER['REDIRECT_STATUS'] = 404;

        echo "\r\n<title>404 Not Found</title>\r\n
404 Not Found
\r\n
\r\nnginx/1.5.9\r\n\r\n\r\n";
        exit();
    }

    return false;
}
// @codeCoverageIgnoreEnd

/**
 * Interface for all objects that can be initialized by IConfig.
 *
 *
Note

 *
 *
This is generally a bad practice as initializing
 * a class state is something that generally should not
 * be handled withing the class. But you never know if
 * there will be a valid use so we made this.

 *
 *
Summary

 *
 *

 * +---------------------------------------------------+
 * | INITIALIZABLE                                     |
 * +---------------------------------------------------+
 * | initialize(): IConfig                             |
 * |                                                   |
 * | $Settings:  IConfig                               |
 * +---------------------------------------------------+
 *

 *
 *

 *
 * @package BLW\Core
 * @api     BLW
 * @since   1.0.0
 * @author  mAsT3RpEE <wotsyula@mast3rpee.tk>
 */
interface IInitializable
{

    /**
     * Initializes object.
     *
     *
Warning

     *
     *
This is not a good way to program and should only be used when
     * unavoidable (ie. classes that must perform tests before use like SpaceRocket).

     *
     * @api BLW
     * @since   1.0.0
     *
     * @param \BLW\Type\IConfig $Config
     *            Settings to use during initialization.
     * @return \BLW\Type\IConfig Returns settings actually used during initialization.
     */
    public function initialize(IConfig $Config);
}

// @codeCoverageIgnoreStart
return true;
// @codeCoverageIgnoreEnd


text:
require 'spec_helper'

describe 'cairo' do

  let(:facts) do
    {
      :boxen_home => '/opt/boxen',
      :boxen_user => 'testuser',
    }
  end

  it { should include_class('homebrew') }
  it { should contain_homebrew__formula('cairo') }
  it { should contain_package('boxen/brews/cairo') }

end


text:
layout: post
title: SIKCA SORULAN SORULAR (SSS)
image: "sodes.jpg"
editor: 'Yönetici'
---
![]({{ site.url }}/images/{{ page.image }})

Bu sayfa SODES Uygulama Usul ve Esaslar hakkında genel bilgi vermek amacıyla hazırlanmış olup Kalkınma Bakanlığınca her yıl güncellenen SODES Uygulama Usul ve Esasları acısından farklılık gösterebilir.

SODES nedir?

İstihdam, sosyal içerme, kültür, sanat, spor alanlarında; göç, yoksulluk ve işsizlik gibi sorunlar ile değişen sosyal yapının ortaya çıkardığı ihtiyaçları karşılamayı amaçlayan, yerel düzeyde hazırlanan ve uygulanan projelerden oluşan, il düzeyinde valiliklerin koordinasyonunda yürütülen, uygulama sürecinde yerel aktörlerin geniş bir biçimde yetkilendirildiği sosyal sorunlara kısa sürede karşılık vermeyi hedefleyen insan odaklı bir programdır.

SODES'in amaçları nelerdir?

SODES ile; beşeri sermayenin geliştirilmesi ve toplumsal bütünleşmenin sağlanmasına yönelik olarak, uygulandığı illerde, yerel dinamikleri harekete geçirerek yoksulluk, göç ve kentleşmeden kaynaklanan sosyal sorunları gidermek, değişen sosyal yapının ortaya çıkardığı ihtiyaçlara karşılık vermek, toplumsal dayanışma ve bütünleşmeyi güçlendirmek, toplumun dezavantajlı kesimlerinin ekonomik ve sosyal hayata daha aktif katılmalarını sağlamak amaçlanmaktadır.

SODES'e kimler başvurabilir?

Kamu kuruluşları,
İl/ilçe özel idareleri,
Belediyeler,
Mahalli idare birlikleri,
Üniversiteler,
Kamu kurumu niteliğindeki meslek kuruluşları,
Sivil toplum kuruluşları.

SODES'e STK'lar başvuru yapabilir mi?

SODES'e kapsamdaki illerde faaliyet gösteren ve ilk başvuru tarihinden en az bir yıl önce kurulmuş bulunan sivil toplum kuruluşları başvuru yapabilir.

SODES başvuruları nereye yapılır?

Proje teklifleri kuruluşlarca http://www.sodes.gov.tr adresinde erişime açılacak olan SODES Bilgi Sistemi (SODES-BİS) aracılığıyla Valiliklere sunulur. Valilikler, projeleri SODES ilkeleri çerçevesinde ön değerlendirmeden geçirerek uygun gördükleri proje tekliflerini hem SODES-BİS hem resmi yazıyla Müsteşarlığa bildirir. Gönderilen proje tekliflerinin elektronik ve yazılı nüshaları arasında fark olması halinde ilgili teklifler değerlendirmeye alınmaz.

SODES başvuruları internet üzerinden yapılmak zorunda mıdır?

Proje teklifleri kuruluşlarca SODES-BİS aracılığıyla internet üzerinden yapılmak zorundadır.

SODES hangi illerde uygulanıyor?

2013 yılı itibariyle SODES Projesi; Adana, Adıyaman, Ağrı, Aksaray, Ardahan, Batman, Bayburt, Bingöl, Bitlis, Diyarbakır, Elazıg, Erzincan, Erzurum, Gaziantep, Gümüşhane, Hakkari, Hatay, Iğdır, Kahramanmaraş, Kars, Kilis, Malatya, Mardin, Mersin, Muş, Niğde, Osmaniye, Siirt, Sivas, Şanlıurfa, Şırnak, Tunceli, Van ve Yozgat İli olmak üzere toplam 34 ilde uygulanmaktadır.

Birden fazla ilde proje yürütülebilir mi?

SODES kapsamındaki iller olması ve valiliğin uygun görmesi halinde yürütülebilir.

SODES'ten desteklenen proje türleri nelerdir?

İstihdam, sosyal içerme, kültür, sanat ve spor alanındaki projeler desteklenmektedir.

İstihdam projelerinin kapsamı nedir?

İstihdam projeleri; ilgili ilde istihdam edilebilirliğin artırılması, ildeki ihtiyaçlara uygun alanlarda nitelikli işgücünün yetiştirilmesi, mesleki bilgi ve becerilerin geliştirilmesi ve kendi işini kurabileceklere destek olunmasına yönelik projelerdir.

Sosyal içerme projelerinin kapsamı nedir?

Sosyal içerme projeleri; ilgili ilde yoksulluğun azaltılması, sosyal yardım alan yoksul kesimin kendi geçimini temin edecek duruma getirilmesine destek olunması, yaşlı, özürlü, kadın ve çocuklar gibi toplumun öncelikli kesimlerinin yaşam standartlarının yükseltilmesi, bunlara götürülen hizmetlerin kalitesinin artırılması ve toplumsal bütünleşmenin sağlanması amacına yönelik projelerdir.

Kültür sanat spor projelerinin kapsamı nedir?

Kültür, sanat ve spor projeleri; ilgili ilde toplumun ihtiyaç duyduğu kültürel, sanatsal ve sportif faaliyetlerin geliştirilmesi ile özellikle çocukların ve gençlerin bu tür faaliyetlerden yararlandırılmasına ve yönlendirilmesine yönelik projelerdir.

SODES'in hedef kitlesi kimlerdir?

SODES'in hedef kitlesi, dezavantajlı konumdaki çocuklar, gençler, kadınlar, işsizler, yoksullar, göç etmişler, yaşlı, özürlü, ve kentlerin gecekondu bölgelerinde yaşayan bireyler ve gruplardır. İstihdam, sosyal içerme ve kültür, sanat ve spor alanlarındaki projelerin bu hedef kitlesine yönelik olması beklenmektedir.

Projelerin süresi ne kadar olmalıdır?

Projelerin süresi en fazla bir yıldır.

SODES başvurularını hangi tarihe kadar yapabiliriz?

Proje teklif tarihleri Valilik tarafından duyurulacaktır.

Proje bütçeleri için alt/üst limit var mıdır?

Projelerin bütçe büyüklüğü her yıl Kalkınma Bakanlığı tarafından belirlenmektedir. 2017 yılı için proje bütçe alt sınırı 100.000,00-TL olup üst sınır 500.000,00-TL dir.

Desteklenecek projelerin seçimindeki kriterler nelerdir?

Projelerin seçimindeki kriterler; SODES amaçlarına uygunluk, sürdürülebilirlik, projenin amacı, faaliyetleri ile bütçesi arasındaki tutarlılık, projeyi öneren kuruluşun proje yürütme kapasitesi, projenin hedef gruplar üzerinde yaratacağı etkiler, proje hedef kitlesinin genişliği ve ilin öncelikleridir.

SODES kapsamındaki projelerde desteklenmesi uygun görülen maliyetler nelerdir?

Personel giderleri, mesleki eğitim kursiyerlerine yapılacak ödemeler, toplum yararına çalışma programlarında istihdam edilecek kişilere yapılacak ödemeler, yolculuk giderleri, gündelik giderler, ekipman ve hizmet (eğitim, nakliye, kira vb.) satın alma maliyetleri, sarf malzemeleri maliyetleri, taşeron maliyetleri (yayın basım, etkinlik organizasyonu vb.), projenin uygulanması için mutlaka gerekli olan ancak yeni bina inşaatı ve inşaatı devam eden binanın tamamlanması hariç inşaat işleri (çocuk parkı, semt sahası, halı saha, tadilat giderleri vb.), mali hizmet giderleri (özellikle havale, sigorta, banka, ihale ve ilan maliyetleri vb.), elektrik, su, telefon vb. idari giderlerdir.

Projelerde koordinatörlerin ücret alması mümkün mü? Alınabiliyorsa bu ücretin miktarı ne kadardır?

SODES Projelerinde koordinatör olarak görev yapacak en fazla bir personele aylık en fazla net 400,00-TL tutarında ödeme yapılabilir.

Projelerde istihdam edilen kamu görevlileri ücret alabilir mi? Alınabiliyorsa bu ücretin miktarı ne kadardır?

Kamu görevlilerine yapılacak ödemeler 5944 sayılı 2010 yılı Merkezi Yönetim Bütçe Kanununun, 657 sayılı Devlet Memurları Kanununun ve kamu personelinin tabi olduğu diğer mevzuatın ilgili hükümleri çerçevesinde olacaktır. Örneğin; öğretmenler 657 sayılı Kanunun 89. maddesi, 439 sayılı Millî Eğitim Bakanlığına Bağlı Yüksek ve Orta Dereceli Okullar Öğretmenleri ile İlkokul Öğretmenlerinin Haftalık Ders Saatleri ile Ek Ders Ücretleri Hakkında Kanun ve bu Kanun çerçevesinde hazırlanan Milli Eğitim Bakanlığı Yönetici ve Öğretmenlerinin Ders ve Ek Ders Saatlerine İlişkin Karar hükümleri çerçevesinde ek ders ücreti alabilmektedir. Kamu görevlilerinin görev alıp bunun karşılığında ücret alması öngörülen projelerde söz konusu kamu görevlilerinin ücret alabilmelerine imkan sağlayan mevzuat valiliklere ibraz edilmelidir.

Projelerde koordinatör dışında istihdam edilen ve kamu görevlisi olmayan kişiler ücret alabilir mi? Alınabiliyorsa bu ücretin miktarı ne kadardır?

Proje koordinatörünün dışında, projelerde tam zamanlı (haftada en az 30 saat) olarak çalışacak personele ödenecek ücret brüt asgari ücretin iki katını, yarı zamanlı olarak (haftada 30 saatten az) çalışacak personele ise brüt asgari ücreti geçmemek üzere ödeme yapılabilir.

Mesleki eğitim kursiyerlerine ve toplum yararına çalışma programlarında istihdam edilecek kişilere ödeme yapılıyor mu?

Mesleki eğitim kursiyerlerine yol ve yemek giderleri için İŞKUR'un belirlediği günlük 20 TL'ye kadar harçlık ödenebilir. Toplum yararına çalışma programları (TYÇP) kapsamında istihdam edilecek kişilere TYÇP süresince asgari ücret üzerinden çalışma süresine göre hesap edilecek ücretten ödeme yapılır.

SODES kapsamında bina inşaatı yapılabilir mi?

Projenin uygulanması için mutlaka gerekli olan ancak yeni bina inşaatı ve inşaatı devam eden binanın tamamlanması hariç inşaat işleri (çocuk parkı, semt sahası, halı saha, tadilat giderleri vb.) yapılabilir. Bu yapım işleri tek başına bir proje olamaz ancak bir projenin bir kolu olabilir.

Projelerde araç alımı yapılabilir mi?

Projelerde gezici sinema ve gezici kütüphane faaliyetleri dışında taşıt alımı yapılamaz.

Proje yürütücüsü olarak proje hesabında oluşacak faiz giderlerini kullanabilir miyim?

Proje yürütücüsü tarafından, projeye ait banka hesabında oluşan faiz ve benzeri gelirler kullanılamaz. Söz konusu tutarlar projenin tamamlanmasını müteakip Valilik hesabına aktarılır.

Proje yürütücüsü olan STK'lar ya da kamu kurumu niteliğindeki meslek kuruluşları proje kapsamındaki mal/hizmet satın alımlarında herhangi bir usule tabi midir?

Kamu kurumu niteliğindeki meslek kuruluşları ile sivil toplum kuruluşlarınca yürütülecek projelerde doğrudan temin usulü uygulanır ve SODES Uygulama Usul ve Esasları ekinde yer alan satın alma sürecine ilişkin hükümlere uyulur.

Projelerde yıl içinde değişiklikler yapılabilir mi?

Projenin amaçları ve faaliyetlerinde değişiklik yapılamaz. Uygulama imkanı ortadan kalkan faaliyetler valinin izniyle iptal edilebilir. Proje bütçesinin imkan vermesi halinde, valinin izniyle, proje amaçlarına uygun yeni faaliyetler eklenebilir. Ayrıca, projelerin uygulama yeri ve süresinde valinin izniyle değişiklik yapılabilir. Proje yürütücüsü; ilgili bütçe kaleminin toplam tutarını değiştirmeyen birim fiyatı ve miktar değişikliklerini, proje koordinatörü ile uzman veya eğitici değişikliklerini, banka hesabı ve iletişim bilgileri değişikliklerini valilikten izin almadan gerçekleştirebilir. Ancak yapılan değişiklik en geç 10 gün içinde valiliğe bildirilir. Projelerde yapılacak tüm değişiklikler SODES-BİS aracılığıyla valiliğe ve Müsteşarlığa 10 gün içerisinde bildirilir.

Başvuru tarihleri geçtikten sonra yıl içinde yeni proje teklif edilebilir mi?

SODES hesabında yeterli ödenek olması halinde, acil ve zorunlu hallerde valilik yıl içerisinde Müsteşarlığa yeni proje teklifinde bulunabilir. Teklif edilen projeler Müsteşarlık tarafından desteklenecek projelerin seçiminde dikkate alınan kriterler bağlamında değerlendirilerek karara bağlanır.

Projenin bütçe kalemleri arasında aktarma yapılabilir mi?

Projenin bütçe kalemleri arasında valinin izniyle aktarma yapılabilir.

Projeye ek ödenek sağlanabilir mi?

Projelerde proje bütçesini aşacak şekilde öngörülmeyen birtakım giderlerin ortaya çıkması durumlarında, valiliğin SODES hesabında yeterli ödenek olması halinde, valilik tarafından projeye ek ödenek sağlanabilir.

Proje için aktarılan ödeneğin fazla gelmesi durumunda, proje yürütücüsü söz konusu ödenek fazlasını kullanabilir mi?

Bu durumda proje yürütücüsü söz konusu ödenek fazlasını kullanamaz. Projelerin gerçekleşen maliyetlerinin proje bütçesinin altında kalması durumunda, proje için tahsis edilen ödenek valilik SODES hesabına aktarılır.

Bir koordinatörün yürütebileceği proje sınırı var mı? Bir koordinatör birden fazla proje yürütebilir mi?

Proje koordinatörlerinin yürüteceği proje sayısı ile ilgili herhangi bir sınırlama bulunmamaktadır. Ancak bunlardan sadece biri için ücret alabilir.

Bütçede yapmak istediğimiz harcama gözükmüyor, olmayan kalemler için yeni bir satır açılıp ihtiyaç olan gider yazılabilir mi? Yoksa olmayan kalemlere ödenek verilmeyecek mi?

"İlgili bütçe kalemi/faaliyet altında "diğer" seçeneğinin bulunması halinde, buraya ilgili olabilecek bütçe kalemi/faaliyet eklenebilir. İlgili bütçe kalemi/faaliyet altında "diğer" seçeneğinin bulunmaması halinde buraya herhangi bir yeni bütçe kalemi/faaliyet eklenemez.
Örneğin, mesleki eğitim faaliyetleri sıralanmakta ve en altta listede öngörülmeyen mesleki eğitim faaliyetleri için "diğer" seçeneği bulunmaktadır. Listede yer almayan bir mesleki eğitim faaliyeti için bu "diğer" seçeneği kullanılabilir. Ancak, örneğin, toplum yararına çalışma programlarının altında "diğer" seçeneği bulunmamaktadır. Bu durumda listede öngörülmeyen ve toplum yararına çalışma programı altında düşünülebilecek herhangi bir faaliyet/bütçe kalemi buraya eklenemez."

SODES kapsamında prefabrik bina yapılabilir mi?

SODES kapsamında prefabrik dahi olsa bina inşaatı yapılamaz.

Yarım kalan bir çocuk oyun alanı tamamlanabilir mi?

Yarım kalan bir çocuk oyun alanı tamamlanamaz ancak özellikle dezavantajlı kesimlerin yaşadığı bölgelerde çocuk parkı yapılmasına ilişkin bir proje içinde ayrı bir kol olarak proje teklifi yapılabilir.

Ek-2 temel proje faaliyetleri doldurulurken başlangıç ve bitiş tarihleri hangi kıstasa göre doldurulacak. Projelerin değerlendirilmesi ne zaman bitecek ve uygulama hangi tarihte başlayacak?

Proje değerlendirilmesi yaklaşık olarak eylül ayı başında bitecek ve uygulama ekim ayı başında başlayacaktır. Bu nedenle, faaliyetlerin en erken başlangıç tarihi için Ekim ayı düşünülebilecektir.

Başvuru yapabilecek kuruluş türünde STK alt başlığında sendikalar belirtilmemiş. Sendikalar potansiyel başvuru sahibi kuruluş olabilir mi?

Sendikalar, STK olduğundan başvuru yapabileceklerdir.

Devlet memuru projede koordinatör olabilir mi? Olursa aylık ne kadar ücret alabilir?

Proje koordinatörü kamu görevlisi olabilir. Kamu görevlilerine yapılacak ödemeler 5944 sayılı 2010 yılı Merkezi Yönetim Bütçe Kanununun, 657 sayılı Devlet Memurları Kanununun ve kamu personelinin tabi olduğu diğer mevzuatın ilgili hükümleri çerçevesinde olacaktır. Örneğin; öğretmenler 657 sayılı Kanunun 89. maddesi, 439 sayılı Millî Eğitim Bakanlığına Bağlı Yüksek ve Orta Dereceli Okullar Öğretmenleri ile İlkokul Öğretmenlerinin Haftalık Ders Saatleri ile Ek Ders Ücretleri Hakkında Kanun ve bu Kanun çerçevesinde hazırlanan Milli Eğitim Bakanlığı Yönetici ve Öğretmenlerinin Ders ve Ek Ders Saatlerine İlişkin Karar hükümleri çerçevesinde ek ders ücreti alabilmektedir. Kamu görevlilerinin görev alıp bunun karşılığında ücret alması öngörülen projelerde söz konusu kamu görevlilerinin ücret alabilmelerine imkan sağlayan mevzuat valiliklere ibraz edilmelidir.

Valilikler Bünyesinde oluşturulacak SODES Ofisleri için gerekli destek ne zaman sağlanabilir?

Valilikler bünyesinde oluşturulacak SODES Ofisleri için gerekli desteğin tutarı ilde desteklenmesi uygun görülen projelerin tutarına bağlı olarak Müsteşarlık tarafından belirlenecektir. Dolayısıyla, projelerin değerlendirmesi bittikten sonra, proje koordinasyon birimleri için gerekli destek sağlanacaktır.

Proje başvuru formunda karakter kısıtlamasından kasıt nedir? (sözcük sayısı mı karakter sayısı mı?)

Karakterle kelime değil, herbir harf, noktalama işareti, boşluk toplamı kastedilmektedir. Ancak, sistem, faaliyetlerin ayrıntılı açıklaması başlıkları için 2000 karakter sınırlamasına yönelik oluşturulmuştur. Zaten amaç faaliyetlerin kısa ve öz yazılmasıdır.

SODES'e STK'lar başvuru yapabilir mi? "Faaliyet gösteren" tanımı nedir?

SODES kapsamdaki illerde faaliyet gösteren ve ilk başvuru tarihinden en az 1 yıl once kurulmuş bulunan STK'lar SODES için başvuru yapabilir. STK'ların başvuru yapabilmeleri için başvuru yapacakları ilde en az 1 yıldır şube/büro olarak tüzel bir kişiliğe sahip olmaları gerekmektedir.

Kooperatiler ve üretici birlikleri SODES başvurusu yapabilir mi?

Kooperatifler ve üretici birlikleri kar amacı güden kuruluşlar olduğundan SODES kapsamında proje yapamazlar.


text:
import { applyMiddleware, compose, createStore } from 'redux'
import thunk from 'redux-thunk'
import { browserHistory } from 'react-router'
import createSagaMiddleware from 'redux-saga'
import makeRootReducer from './reducers'
import { syncSagasStart } from './sagas'
import { updateLocation } from './location'

export default (initialState = {}) => {
  const sagaMiddleware = createSagaMiddleware()
  // ======================================================
  // Middleware Configuration
  // ======================================================
  const middleware = [sagaMiddleware, thunk]

  // ======================================================
  // Store Enhancers
  // ======================================================
  const enhancers = []

  let composeEnhancers = compose

  if (__DEV__) {
    const composeWithDevToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
    if (typeof composeWithDevToolsExtension === 'function') {
      composeEnhancers = composeWithDevToolsExtension
    }
  }

  // ======================================================
  // Store Instantiation and HMR Setup
  // ======================================================
  const store = createStore(
    makeRootReducer(),
    initialState,
    composeEnhancers(
      applyMiddleware(...middleware),
      ...enhancers
    )
  )
  store.asyncReducers = {}
  store.runningSagas = {}
  store.sagaMiddleware = sagaMiddleware
  syncSagasStart(store)

  // To unsubscribe, invoke `store.unsubscribeHistory()` anytime
  store.unsubscribeHistory = browserHistory.listen(updateLocation(store))

  if (module.hot) {
    module.hot.accept('./reducers', () => {
      const reducers = require('./reducers').default
      store.replaceReducer(reducers(store.asyncReducers))
    })
  }

  return store
}


text:
@font-face {
  font-family: "fontawesome-ep_webrtc";
  /* License: ../fonts/fontello/LICENSE.txt */
  src: url("../fonts/fontello/font/fontawesome-custom.woff2") format("woff2");
  font-weight: normal;
  font-style: normal;
}

#rtcbox {
  align-items: start;
  display: none;
  flex: 0 1 auto;
  flex-direction: column;
  justify-content: start;
  padding: 0;
  order: -1; /* on left side */
  box-sizing: border-box;
  background-color: transparent;
  height: auto;
  max-height: 100%;
  max-width: 100%;
  overflow: auto;
  width: auto;
}

#rtcbox .video-container {
  flex: 0 0 auto;
  align-items: center;
  background-color: black;
  border: 1px solid black;
  border-left: 5px solid;
  box-sizing: content-box;
  overflow: hidden;
  position: relative;
}
#rtcbox .video-container:not(:first-child) {
  margin-top: 5px;
}
#rtcbox video {
  box-sizing: content-box;
  background-color: black;
  height: 100%;
  object-fit: contain;
  width: 100%;
}

#rtcbox .video-container .interface-btn,
#rtcbox .video-container .user-name,
#rtcbox .video-container .resize-handle {
  --interface-text-color-rgb: 87, 98, 115; /* --dark-color */
  --interface-background-color-rgb: 242, 243, 244; /* --light-color */
  --interface-text-alpha: 0.6;
  --interface-background-alpha: 0.2;
  background-color: rgba(var(--interface-background-color-rgb),
                         var(--interface-background-alpha));
  color: rgba(var(--interface-text-color-rgb), var(--interface-text-alpha));
  transition: background-color .2s, color .2s;
}
#rtcbox .video-container:hover .interface-btn,
#rtcbox .video-container:hover .user-name,
#rtcbox .video-container:hover .resize-handle {
  --interface-text-alpha: 0.8;
  --interface-background-alpha: 0.7;
}
#rtcbox .video-container:hover .interface-btn:hover,
#rtcbox .video-container:hover .user-name:hover,
#rtcbox .video-container:hover .resize-handle:hover {
  --interface-text-alpha: 1.0;
  --interface-background-alpha: 1.0;
}
#rtcbox .video-container:hover .interface-btn:hover {
  filter: drop-shadow(0 0 2px rgba(var(--interface-text-color-rgb),
                                   var(--interface-text-alpha)));
}
#rtcbox .video-container .disallowed {
  display: none;
}

#rtcbox .interface-container {
  display: flex;
  min-width: min-content;
  position: absolute;
  bottom: 0px;
  left: 0px;
  padding: 5px;
  width: 100%;
  z-index: 2;
}
#rtcbox .interface-btn {
  flex: 0 0 auto;
  border-radius: 50%;
  padding: 5px;
  margin: 3px;
  cursor: pointer;
  width: 28px;
  height: 28px;
}

#rtcbox .interface-btn.audio-btn:before { content: '\e83d'; }
#rtcbox .interface-btn.audio-btn.muted:before { content: '\e83e'; }

#rtcbox .interface-btn.video-btn:before { content: '\e83b'; }
#rtcbox .interface-btn.video-btn.off:before { content: '\e83c'; }

#rtcbox .interface-btn.screenshare-btn:before {
  content: "\f108";
  font-family: "fontawesome-ep_webrtc";
}
#rtcbox .interface-btn.screenshare-btn.off:before { content: "\f109"; }

#rtcbox .interface-btn.enlarge-btn:before { content: '\e840'; }
#rtcbox .interface-btn.enlarge-btn.large:before { content: '\e83f'; }

#rtcbox .video-container .interface-container .interface-btn.error-btn {
  --interface-background-alpha: 1.0;
  --interface-text-alpha: 1.0;
  --interface-text-color-rgb: 255, 0, 0;
}
#rtcbox .video-container .interface-container .interface-btn.error-btn:before {
  content: "\f071";
  font-family: "fontawesome-ep_webrtc";
}

#rtcbox .video-container .resize-handle {
  --handle-size: 15px;
  background-color: transparent;
  bottom: 0;
  cursor: nwse-resize;
  font-family: "fontawesome-ep_webrtc";
  font-size: var(--handle-size);
  line-height: var(--handle-size);
  position: absolute;
  right: 0;
  text-shadow: 1px 1px 0 rgba(var(--interface-background-color-rgb),
                              var(--interface-background-alpha));
  touch-action: none;
  user-select: none;
  z-index: 3;
}
#rtcbox .video-container .resize-handle:before {
  content: "\e83f";
}

#rtcbox .video-container .user-name {
  /*
   * Use absolute positioning to remove the name from the normal document flow.
   * This prevents a long name from making the .video-container div overly wide.
   */
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  font-weight: bold;
  height: min-content;
  overflow: hidden;
  padding: 0px 8px;
  white-space: nowrap;
  text-overflow: ellipsis;
  z-index: 1;
}
#rtcbox .video-container.local-user {
  order: -1; /* first position */
}

@media (max-width: 800px) {
  #editorcontainerbox {
    flex-direction: column;
  }
  #rtcbox {
    flex-direction: row;
    order: 2;
  }
  #rtcbox .video-container:not(:first-child) {
    margin-top: 0;
    margin-left: 5px;
  }
}


text:
/*global CompilerContext, shouldCompileTo, shouldThrow */
describe('blocks', function() {
  it("array", function() {
    var string   = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
    var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
    shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
                    "Arrays iterate over the contents when not empty");

    shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
                    "Arrays ignore the contents when empty");
  });

  it('array without data', function() {
    var string   = '{{#goodbyes}}{{text}}{{/goodbyes}} {{#goodbyes}}{{text}}{{/goodbyes}}';
    var hash     = {goodbyes: [{text: 'goodbye'}, {text: 'Goodbye'}, {text: 'GOODBYE'}], world: 'world'};
    shouldCompileTo(string, [hash,,,,false], 'goodbyeGoodbyeGOODBYE goodbyeGoodbyeGOODBYE');
  });

  it("array with @index", function() {
    var string = "{{#goodbyes}}{{@index}}. {{text}}! {{/goodbyes}}cruel {{world}}!";
    var hash   = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};

    var template = CompilerContext.compile(string);
    var result = template(hash);

    equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
  });

  it("empty block", function() {
    var string   = "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!";
    var hash     = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
    shouldCompileTo(string, hash, "cruel world!",
                    "Arrays iterate over the contents when not empty");

    shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
                    "Arrays ignore the contents when empty");
  });

  it("block with complex lookup", function() {
    var string = "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}";
    var hash     = {name: "Alan", goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}]};

    shouldCompileTo(string, hash, "goodbye cruel Alan! Goodbye cruel Alan! GOODBYE cruel Alan! ",
                    "Templates can access variables in contexts up the stack with relative path syntax");
  });

  it('multiple blocks with complex lookup', function() {
    var string = '{{#goodbyes}}{{../name}}{{../name}}{{/goodbyes}}';
    var hash     = {name: 'Alan', goodbyes: [{text: 'goodbye'}, {text: 'Goodbye'}, {text: 'GOODBYE'}]};

    shouldCompileTo(string, hash, 'AlanAlanAlanAlanAlanAlan');
  });

  it("block with complex lookup using nested context", function() {
    var string = "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}";

    shouldThrow(function() {
      CompilerContext.compile(string);
    }, Error);
  });

  it("block with deep nested complex lookup", function() {
    var string = "{{#outer}}Goodbye {{#inner}}cruel {{../sibling}} {{../../omg}}{{/inner}}{{/outer}}";
    var hash = {omg: "OMG!", outer: [{ sibling: 'sad', inner: [{ text: "goodbye" }] }] };

    shouldCompileTo(string, hash, "Goodbye cruel sad OMG!");
  });

  describe('inverted sections', function() {
    it("inverted sections with unset value", function() {
      var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
      var hash = {};
      shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value isn't set.");
    });

    it("inverted section with false value", function() {
      var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
      var hash = {goodbyes: false};
      shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is false.");
    });

    it("inverted section with empty set", function() {
      var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
      var hash = {goodbyes: []};
      shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is empty set.");
    });

    it("block inverted sections", function() {
      shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people"},
        "No people");
    });

    it("block inverted sections with empty arrays", function() {
      shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people", people: []},
        "No people");
    });
  });

  describe('standalone sections', function() {
    it('block standalone else sections', function() {
      shouldCompileTo('{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n', {none: 'No people'},
        'No people\n');
      shouldCompileTo('{{#none}}\n{{.}}\n{{^}}\n{{none}}\n{{/none}}\n', {none: 'No people'},
        'No people\n');
      shouldCompileTo('{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n', {none: 'No people'},
        'No people\n');
    });
    it('should handle nesting', function() {
      shouldCompileTo('{{#data}}\n{{#if true}}\n{{.}}\n{{/if}}\n{{/data}}\nOK.', {data: [1, 3, 5]}, '1\n3\n5\nOK.');
    });
  });

  describe('compat mode', function() {
    it("block with deep recursive lookup lookup", function() {
      var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg}}{{/inner}}{{/outer}}";
      var hash = {omg: "OMG!", outer: [{ inner: [{ text: "goodbye" }] }] };

      shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel OMG!");
    });
    it("block with deep recursive pathed lookup", function() {
      var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}";
      var hash = {omg: {yes: "OMG!"}, outer: [{ inner: [{ yes: 'no', text: "goodbye" }] }] };

      shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel OMG!");
    });
    it("block with missed recursive lookup", function() {
      var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}";
      var hash = {omg: {no: "OMG!"}, outer: [{ inner: [{ yes: 'no', text: "goodbye" }] }] };

      shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel ");
    });
  });
});


text:
using SFA.DAS.CommitmentsV2.Types;

namespace SFA.DAS.CommitmentsV2.Api.Types.Requests
{
    public class GetCohortsRequest
    {
        public long? AccountId { get; set; }
        public long? ProviderId { get; set; }
    }
}


text:
checklists
==========

a simple checklist app


text:
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    style="@style/CustomStyle.RootView">

  <!-- ProgressBar -->

  <ProgressBar
      android:id="@+id/pb_loading"
      style="@style/CustomStyle.ProgressBar"/>

  <!-- DraggableView -->

  <!--If you want to lear more about how to use DraggablePanel take a look to this project: https://github.com/pedrovgs/DraggablePanel -->

  <com.github.pedrovgs.DraggableView
      xmlns:draggable_view="http://schemas.android.com/apk/res-auto"
      android:id="@+id/draggable_view"
      draggable_view:top_view_id="@+id/iv_fan_art"
      draggable_view:bottom_view_id="@+id/lv_chapters"
      draggable_view:top_view_x_scale_factor="@dimen/x_draggable_scale_factor"
      draggable_view:top_view_y_scale_factor="@dimen/y_draggable_scale_factor"
      draggable_view:top_view_margin_right="@dimen/main_margin"
      draggable_view:top_view_margin_bottom="@dimen/main_margin"
      style="@style/AppTheme.Chapter.DraggableView">

    <!-- ListView Chapters -->

    <ListView
        android:id="@+id/lv_chapters"
        android:layout_below="@+id/iv_fan_art"
        style="@style/CustomStyle.ListView"/>

    <!-- TvShow Fan Art -->

    <ImageView
        android:id="@+id/iv_fan_art"
        android:layout_alignParentTop="true"
        style="@style/CustomStyle.Image.TvShowFranArt"/>

  </com.github.pedrovgs.DraggableView>

</FrameLayout>


text:
<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- 按下时效果 -->
    <item android:state_pressed="true"><shape>
            <padding android:bottom="8dp" android:left="12dp" android:top="8dp"></padding>

            <solid android:color="#ffe0e0e0" />

            <stroke android:width="0.6dp" android:color="#ccc" />

            <corners android:radius="3dp" />
        </shape></item>
    <!-- 默认效果 -->
    <item android:state_pressed="false"><shape>
            <padding android:bottom="8dp" android:left="12dp" android:top="8dp"></padding>

            <solid android:color="#aae0e0e0" />

            <stroke android:width="0.6dp" android:color="#ccc" />

            <corners android:radius="3dp" />
        </shape></item>

</selector>


text:
package org.yoooo.se1;

import com.sun.istack.internal.NotNull;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * An implementation of simple directed weighted using adjacency list.
 *
 * @param <V> the graph vertex type
 * @param <E> the graph edge type
 */
public class SimpleDirectedWeightGraph<V, E> implements WeightedGraph<V, E> {
    private Map<V, Set<E>> mOutgoingEdges = new HashMap<>();
    private Map<E, V> mSourceVertexMap = new HashMap<>();
    private Map<E, V> mTargetVertexMap = new HashMap<>();
    private Map<E, Double> mEdgeWeightMap = new HashMap<>();
    private Map<V, Map<V, E>> mVertexOutEdgeMap = new HashMap<>();
    private EdgeFactory<V, E> mEdgeFactory;

    /**
     * Creates a new simple directed graph.
     *
     * @param edgeFactory edge factory of the new graph.
     */
    public SimpleDirectedWeightGraph(final @NotNull EdgeFactory<V, E> edgeFactory) {
        mEdgeFactory = edgeFactory;
    }

    /**
     * @see Graph#outgoingEdgesOf(Object)
     */
    @Override
    public Set<E> outgoingEdgesOf(final V v) {
        if (mOutgoingEdges.containsKey(v)) {
            return Collections.unmodifiableSet(mOutgoingEdges.get(v));
        } else {
            return null;
        }
    }

    /**
     * @see WeightedGraph#setEdgeWeight(Object, double)
     */
    @Override
    public void setEdgeWeight(final E e, final double weight) {
        if (mEdgeWeightMap.containsKey(e)) {
            mEdgeWeightMap.put(e, weight);
        } else {
            throw new IllegalArgumentException("Edge does not exist");
        }
    }

    /**
     * @see Graph#getEdge(Object, Object)
     */
    @Override
    public E getEdge(final V source, final V target) {
        if (!mOutgoingEdges.containsKey(source) || !mOutgoingEdges.containsKey(target)) {
            return null;
        }
        return mVertexOutEdgeMap.get(source).get(target);
    }

    /**
     * @see Graph#addEdge(Object, Object)
     */
    @Override
    public E addEdge(final V source, final V target) {
        if (!mOutgoingEdges.containsKey(source) || !mOutgoingEdges.containsKey(target)) {
            return null;
        }
        E edge = mEdgeFactory.createEdge(source, target);
        mOutgoingEdges.get(source).add(edge);
        mSourceVertexMap.put(edge, source);
        mTargetVertexMap.put(edge, target);
        mEdgeWeightMap.put(edge, 1.0);
        mVertexOutEdgeMap.get(source).put(target, edge);
        return edge;
    }

    /**
     * @see Graph#addVertex(Object)
     */
    @Override
    public boolean addVertex(final V v) {
        if (mOutgoingEdges.containsKey(v)) {
            return false;
        }
        mOutgoingEdges.put(v, new HashSet<>());
        mVertexOutEdgeMap.put(v, new HashMap<>());
        return true;
    }

    /**
     * @see Graph#getEdgeSource(Object)
     */
    @Override
    public V getEdgeSource(final E e) {
        return mSourceVertexMap.get(e);
    }

    /**
     * @see Graph#getEdgeTarget(Object)
     */
    @Override
    public V getEdgeTarget(final E e) {
        return mTargetVertexMap.get(e);
    }

    /**
     * @see Graph#getEdgeWeight(Object)
     */
    @Override
    public double getEdgeWeight(final E e) {
        return mEdgeWeightMap.get(e);
    }

    /**
     * @see Graph#vertexSet()
     */
    @Override
    public Set<V> vertexSet() {
        return Collections.unmodifiableSet(mOutgoingEdges.keySet());
    }

    /**
     * @see Graph#outDegreeOf(Object)
     */
    @Override
    public int outDegreeOf(final V v) {
        return 0;
    }
}


text:
// Copyright 2007-2011 Chris Patterson, Dru Sellers, Travis Smith, et. al.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

using Burrows.Configuration;
using Burrows.Configuration.BusConfigurators;
using Burrows.Configuration.SubscriptionConfigurators;
using Burrows.Endpoints;

namespace Burrows.Testing.ScenarioBuilders
{
    using System;
    using Diagnostics;
    using Magnum.Extensions;
    using Scenarios;

    public interface IBusScenarioBuilder : IEndpointScenarioBuilder<IBusTestScenario>
    {
        /// <summary>
        /// Configure any bus-specific items as part of building the test scenario
        /// </summary>
        /// <param name="configureCallback"></param>
        void ConfigureBus(Action<IServiceBusConfigurator> configureCallback);

        /// <summary>
        /// Configure the subscriptions for a test using this scenario.
        /// </summary>
        /// <param name="configureCallback"></param>
        void ConfigureSubscriptions(Action<ISubscriptionBusServiceConfigurator> configureCallback);
    }

    /// <summary>
    /// Implementation for the test scenario, but abstract for others to customize it. Sets some defaults in the c'tor, which you
    /// can override with the <see cref="ConfigureBus"/> and <see cref="ConfigureSubscriptions"/> methods.
    /// </summary>
    public abstract class BusScenarioBuilder :
        EndpointScenarioBuilder<IBusTestScenario>,
        IBusScenarioBuilder
    {
        private readonly ServiceBusConfigurator _configurator;
        private readonly ServiceBusDefaultSettings _settings;

        /// <summary>
        /// c'tor
        /// </summary>
        /// <param name="uri">The uri to receive from during the scenario.</param>
        protected BusScenarioBuilder(Uri uri)
        {
            _settings = new ServiceBusDefaultSettings();
            _settings.ConcurrentConsumerLimit = 1;
            _settings.ReceiveTimeout = 50.Milliseconds();

            _configurator = new ServiceBusConfigurator(_settings);
            _configurator.ReceiveFrom(uri);
        }

        public void ConfigureBus(Action<IServiceBusConfigurator> configureCallback)
        {
            configureCallback(_configurator);
        }

        public void ConfigureSubscriptions(Action<ISubscriptionBusServiceConfigurator> configureCallback)
        {
            _configurator.Subscribe(configureCallback);
        }

        public override IBusTestScenario Build()
        {
            IEndpointFactory endpointFactory = BuildEndpointFactory();

            var scenario = new BusTestScenario(endpointFactory);

            _configurator.ChangeSettings(x => { x.EndpointCache = scenario.EndpointCache; });
            _configurator.EnableMessageTracing();

            scenario.Bus = _configurator.CreateServiceBus();

            return scenario;
        }
    }
}


text:
package com.jcwhatever.resourcepackermc.generators;

import com.jcwhatever.resourcepackermc.ResourcePackFiles;
import com.jcwhatever.resourcepackermc.sounds.MinecraftSounds;
import com.jcwhatever.resourcepackermc.sounds.OggSound;

import java.io.File;
import java.util.Collection;

/**
 * Generates a text file with information about extra
 * sounds that do not replace minecraft sounds.
 */
public class SoundsExtraTxtGenerator extends SoundsTxtGenerator {

    @Override
    public void generateFile(ResourcePackFiles packFiles, File root) {
        File file = new File(root, "SOUNDS_EXTRA.TXT");
        generate(packFiles, file);
    }

    @Override
    protected Collection<OggSound> getSounds(ResourcePackFiles files) {
        return MinecraftSounds.removeMinecraft(files.getSounds());
    }
}


text:
import feedparser
import socket

from django.core.management import call_command
from django.utils import timezone
from mock import patch, PropertyMock
from rache import job_details, schedule_job
from requests import RequestException
from requests.packages.urllib3.exceptions import (LocationParseError,
                                                  DecodeError)
from rq.timeouts import JobTimeoutException
from six.moves.http_client import IncompleteRead

from feedhq import es
from feedhq.feeds.models import Favicon, UniqueFeed, Feed
from feedhq.feeds.tasks import update_feed
from feedhq.feeds.utils import FAVICON_FETCHER, USER_AGENT, epoch_to_utc
from feedhq.utils import get_redis_connection

from .factories import FeedFactory, UserFactory
from .test_feeds import data_file, responses
from . import TestCase, patch_job

class UpdateTests(TestCase):
    @patch("requests.get")
    def test_parse_error(self, get):
        get.side_effect = LocationParseError("Failed to parse url")
        FeedFactory.create()
        unique = UniqueFeed.objects.get()
        self.assertTrue(unique.muted)
        self.assertEqual(unique.error, UniqueFeed.PARSE_ERROR)

    @patch("requests.get")
    def test_decode_error(self, get):
        get.side_effect = DecodeError("Received response with content-encoding"
                                      ": gzip, but failed to decode it.")
        FeedFactory.create()
        unique = UniqueFeed.objects.get()
        data = job_details(unique.url, connection=get_redis_connection())
        self.assertEqual(data['backoff_factor'], 2)
        self.assertEqual(data['error'], UniqueFeed.DECODE_ERROR)

    @patch("requests.get")
    def test_incomplete_read(self, get):
        get.side_effect = IncompleteRead("0 bytes read")
        FeedFactory.create()
        f = UniqueFeed.objects.get()
        self.assertFalse(f.muted)
        data = job_details(f.url, connection=get_redis_connection())
        self.assertEqual(data['error'], f.CONNECTION_ERROR)

    @patch("requests.get")
    def test_socket_timeout(self, get):
        m = get.return_value
        type(m).content = PropertyMock(side_effect=socket.timeout)
        FeedFactory.create()
        f = UniqueFeed.objects.get()
        self.assertFalse(f.muted)
        data = job_details(f.url, connection=get_redis_connection())
        self.assertEqual(data['error'], f.TIMEOUT)

    @patch('requests.get')
    def test_ctype(self, get):
        # Updatefeed doesn't fail if content-type is missing
        get.return_value = responses(200, 'sw-all.xml', headers={})
        feed = FeedFactory.create()
        update_feed(feed.url)
        get.assert_called_with(
            feed.url,
            headers={'User-Agent': USER_AGENT % '1 subscriber',
                     'Accept': feedparser.ACCEPT_HEADER},
            timeout=10, auth=None)

        get.return_value = responses(200, 'sw-all.xml',
                                     headers={'Content-Type': None})
        update_feed(feed.url)
        get.assert_called_with(
            feed.url,
            headers={'User-Agent': USER_AGENT % '1 subscriber',
                     'Accept': feedparser.ACCEPT_HEADER},
            timeout=10, auth=None)

    @patch('requests.get')
    def test_permanent_redirects(self, get):
        """Updating the feed if there's a permanent redirect"""
        get.return_value = responses(
            301, redirection='permanent-atom10.xml',
            headers={'Content-Type': 'application/rss+xml'})
        feed = FeedFactory.create()
        feed = Feed.objects.get(pk=feed.id)
        self.assertEqual(feed.url, 'permanent-atom10.xml')

    @patch('requests.get')
    def test_temporary_redirect(self, get):
        """Don't update the feed if the redirect is not 301"""
        get.return_value = responses(
            302, redirection='atom10.xml',
            headers={'Content-Type': 'application/rss+xml'})
        feed = FeedFactory.create()
        get.assert_called_with(
            feed.url, timeout=10, auth=None,
            headers={'User-Agent': USER_AGENT % '1 subscriber',
                     'Accept': feedparser.ACCEPT_HEADER},
        )
        feed = Feed.objects.get(pk=feed.id)
        self.assertNotEqual(feed.url, 'atom10.xml')

    @patch('requests.get')
    def test_content_handling(self, get):
        """The content section overrides the subtitle section"""
        get.return_value = responses(200, 'atom10.xml')
        user = UserFactory.create(ttl=99999)
        FeedFactory.create(name='Content', url='http://atom10.xml', user=user)
        [entry] = es.manager.user(user).fetch(annotate=user)['hits']
        self.assertEqual(entry.sanitized_content(),
                         "
Watch out for  nasty tricks
")

        self.assertEqual(entry.author, 'Mark Pilgrim (mark@example.org)')

    @patch('requests.get')
    def test_gone(self, get):
        """Muting the feed if the status code is 410"""
        get.return_value = responses(410)
        FeedFactory.create(url='http://gone.xml')
        feed = UniqueFeed.objects.get(url='http://gone.xml')
        self.assertTrue(feed.muted)

    @patch('requests.get')
    def test_errors(self, get):
        codes = [400, 401, 403, 404, 500, 502, 503]

        def get_side_effect():
            yield responses(304)
            for code in codes:
                yield responses(code)
        get.side_effect = get_side_effect()
        feed = FeedFactory.create()
        self.assertEqual(len(get.call_args_list), 1)

        for code in codes:
            get.return_value = responses(code)
            feed = UniqueFeed.objects.get(url=feed.url)
            self.assertFalse(feed.muted)
            self.assertEqual(feed.job_details.get('error'), None)
            self.assertEqual(feed.job_details['backoff_factor'], 1)
            feed.schedule()
            data = job_details(feed.url, connection=get_redis_connection())

            update_feed(feed.url, backoff_factor=data['backoff_factor'])

            feed = UniqueFeed.objects.get(url=feed.url)
            self.assertFalse(feed.muted)
            data = job_details(feed.url, connection=get_redis_connection())
            self.assertEqual(data['error'], code)
            self.assertEqual(data['backoff_factor'], 2)

            # Restore status for next iteration
            schedule_job(feed.url, backoff_factor=1, error=None, schedule_in=0)
            feed = UniqueFeed.objects.get(url=feed.url)
            self.assertEqual(feed.job_details.get('error'), None)

    @patch('requests.get')
    def test_too_many_requests(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create()

        get.return_value = responses(429)
        update_feed(feed.url, backoff_factor=1)
        data = job_details(feed.url, connection=get_redis_connection())
        # retry in 1 min
        self.assertTrue(
            58 <
            (epoch_to_utc(data['schedule_at']) - timezone.now()).seconds <
            60
        )

    @patch('requests.get')
    def test_too_many_requests_retry(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create()

        get.return_value = responses(429, headers={'Retry-After': '3600'})
        update_feed(feed.url, backoff_factor=1)
        data = job_details(feed.url, connection=get_redis_connection())
        # Retry in 1 hour
        self.assertTrue(
            3590 <
            (epoch_to_utc(data['schedule_at']) - timezone.now()).seconds <
            3600
        )

        # Other requests to same domain
        get.reset_mock()
        get.assert_not_called()
        update_feed(feed.url, backoff_factor=1)
        get.assert_not_called()

    @patch('requests.get')
    def test_backoff(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create()
        feed = UniqueFeed.objects.get(url=feed.url)
        detail = feed.job_details
        self.assertFalse('error' in detail)
        self.assertEqual(detail['backoff_factor'], 1)
        feed.schedule()
        data = job_details(feed.url, connection=get_redis_connection())

        get.return_value = responses(502)
        for i in range(12):
            update_feed(feed.url, backoff_factor=data['backoff_factor'])
            feed = UniqueFeed.objects.get(url=feed.url)
            self.assertFalse(feed.muted)
            data = job_details(feed.url, connection=get_redis_connection())
            self.assertEqual(data['error'], 502)
            self.assertEqual(data['backoff_factor'], min(i + 2, 10))

        get.side_effect = RequestException
        feed = UniqueFeed.objects.get()
        patch_job(feed.url, error=None, backoff_factor=1)
        data = job_details(feed.url, connection=get_redis_connection())

        for i in range(12):
            update_feed(feed.url, backoff_factor=data['backoff_factor'])
            feed = UniqueFeed.objects.get(url=feed.url)
            self.assertFalse(feed.muted)
            data = job_details(feed.url, connection=get_redis_connection())
            self.assertEqual(data['error'], 'timeout')
            self.assertEqual(data['backoff_factor'], min(i + 2, 10))

    @patch("requests.get")
    def test_etag_modified(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create()
        update_feed(feed.url, etag='etag', modified='1234', subscribers=2)
        get.assert_called_with(
            feed.url,
            headers={
                'User-Agent': USER_AGENT % '2 subscribers',
                'Accept': feedparser.ACCEPT_HEADER,
                'If-None-Match': b'etag',
                'If-Modified-Since': b'1234',
            }, timeout=10, auth=None)

    @patch("requests.get")
    def test_restore_backoff(self, get):
        get.return_value = responses(304)
        FeedFactory.create()
        feed = UniqueFeed.objects.get()
        feed.error = 'timeout'
        feed.backoff_factor = 5
        feed.save()
        update_feed(feed.url, error=feed.error,
                    backoff_factor=feed.backoff_factor)

        data = job_details(feed.url, connection=get_redis_connection())
        self.assertEqual(data['backoff_factor'], 1)
        self.assertTrue('error' not in data)

    @patch('requests.get')
    def test_no_date_and_304(self, get):
        """If the feed does not have a date, we'll have to find one.
        Also, since we update it twice, the 2nd time it's a 304 response."""
        get.return_value = responses(200, 'no-date.xml')
        feed = FeedFactory.create()

        # Update the feed twice and make sure we don't index the content twice
        update_feed(feed.url)
        feed1 = Feed.objects.get(pk=feed.id)
        count1 = feed1.entries.count()

        update_feed(feed1.url)
        feed2 = Feed.objects.get(pk=feed1.id)
        count2 = feed2.entries.count()

        self.assertEqual(count1, count2)

    @patch("requests.get")
    def test_uniquefeed_deletion(self, get):
        get.return_value = responses(304)
        f = UniqueFeed.objects.create(url='http://example.com')
        self.assertEqual(UniqueFeed.objects.count(), 1)
        call_command('delete_unsubscribed')
        UniqueFeed.objects.update_feed(f.url)
        self.assertEqual(UniqueFeed.objects.count(), 0)

    @patch('requests.get')
    def test_no_link(self, get):
        get.return_value = responses(200, 'rss20.xml')
        user = UserFactory.create(ttl=99999)
        feed = FeedFactory.create(user=user, category__user=user)
        update_feed(feed.url)

        count = self.counts(user, all={})['all']
        self.assertEqual(count, 1)

        get.return_value = responses(200, 'no-link.xml')
        feed.url = 'http://no-link.xml'
        feed.save(update_fields=['url'])
        update_feed(feed.url)

        count = self.counts(user, all={})['all']
        self.assertEqual(count, 1)

    @patch('requests.get')
    def test_task_timeout_handling(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create()
        get.side_effect = JobTimeoutException
        self.assertEqual(
            UniqueFeed.objects.get().job_details['backoff_factor'], 1)
        update_feed(feed.url)
        data = job_details(feed.url, connection=get_redis_connection())
        self.assertEqual(data['backoff_factor'], 2)

class FaviconTests(TestCase):
    @patch("requests.get")
    def test_declared_favicon(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create(url='http://example.com/feed')
        patch_job(feed.url, link='http://example.com')

        with open(data_file('bruno.im.png'), 'rb') as f:
            fav = f.read()

        class Response:
            status_code = 200
            content = fav
            headers = {'foo': 'bar'}
        get.reset_mock()
        get.return_value = Response()
        Favicon.objects.update_favicon(feed.url)
        get.assert_called_with(
            'http://example.com/favicon.ico',
            headers={'User-Agent': FAVICON_FETCHER},
            timeout=10,
        )

    @patch("requests.get")
    def test_favicon_empty_document(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create(url='http://example.com/feed')
        patch_job(feed.url, link='http://example.com')

        class Response:
            status_code = 200
            content = '<?xml version="1.0" encoding="iso-8859-1"?>'
            headers = {}
        get.return_value = Response()
        Favicon.objects.update_favicon(feed.url)

    @patch("requests.get")
    def test_favicon_parse_error(self, get):
        get.return_value = responses(304)
        feed = FeedFactory.create(url='http://example.com/feed')
        patch_job(feed.url, link='http://example.com')

        get.side_effect = LocationParseError("Failed to parse url")
        Favicon.objects.update_favicon(feed.url)


text:
require 'net/http'
require 'openssl'
require 'uri'

module AdminUI
  class Utils
    HTTP_DELETE = 'DELETE'.freeze
    HTTP_GET    = 'GET'.freeze
    HTTP_HEAD   = 'HEAD'.freeze
    HTTP_PATCH  = 'PATCH'.freeze
    HTTP_PUT    = 'PUT'.freeze
    HTTP_POST   = 'POST'.freeze

    HTTP_METHODS_MAP =
      {
        HTTP_DELETE => Net::HTTP::Delete,
        HTTP_GET    => Net::HTTP::Get,
        HTTP_HEAD   => Net::HTTP::Head,
        HTTP_PATCH  => Net::HTTP::Patch,
        HTTP_PUT    => Net::HTTP::Put,
        HTTP_POST   => Net::HTTP::Post
      }.freeze

    def self.time_in_milliseconds(time = Time.now)
      (time.to_f * 1000).to_i
    end

    def self.get_method_class(method_string)
      HTTP_METHODS_MAP[method_string.upcase]
    end

    def self.http_request(config, logger, uri_string, method = HTTP_GET, basic_auth_array = nil, body = nil, authorization_header = nil, content_type = nil, if_match = nil)
      uri = URI.parse(uri_string)

      path  = uri.path
      path += "?#{uri.query}" unless uri.query.nil?

      http             = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl     = uri.scheme.to_s.casecmp('https').zero?
      http.verify_mode = config.cloud_controller_ssl_verify_none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
      request          = get_method_class(method).new(path)

      request.basic_auth(basic_auth_array[0], basic_auth_array[1]) unless basic_auth_array.nil? || basic_auth_array.length < 2
      request['Authorization'] = authorization_header unless authorization_header.nil?
      request['Accept']        = 'application/json'
      request['Content-Type']  = content_type unless content_type.nil?
      request['If-Match']      = if_match unless if_match.nil?

      request.body = body if body

      http.set_debug_output(logger) if config.http_debug

      retries_remaining = 2
      loop do
        return http.request(request)
      rescue EOFError, Timeout::Error
        raise if retries_remaining < 1

        retries_remaining -= 1
      end
    end

    def self.hours_in_a_day(num_minutes)
      minutes_in_a_day = num_minutes % (24 * 60)
      minutes_in_a_day / 60
    end

    def self.minutes_in_an_hour(num_minutes)
      num_minutes % 60
    end

    def self.symbolize_keys(object)
      case object
      when Array
        new_array = []
        object.each { |item| new_array.push(symbolize_keys(item)) }
        new_array
      when Hash
        new_hash = {}
        object.each { |key, value| new_hash[key.to_sym] = symbolize_keys(value) }
        new_hash
      else
        object
      end
    end

    def self.convert_bytes_to_megabytes(bytes)
      (bytes / 1_048_576.0).round
    end

    def self.convert_kilobytes_to_megabytes(kilobytes)
      (kilobytes / 1_024.0).round
    end
  end
end


text:
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.Mvc;
using DataLayer;
using Models;

namespace Web.Controllers
{
    public class LoansController : Controller
    {
        private LibraryDbContext db = new LibraryDbContext();

        // GET: Loans
        public ActionResult Index()
        {
            var loans = db.Loans.Include(l => l.Book).Include(l => l.Borrower);
            return View(loans.ToList());
        }

        // GET: Loans/Details/5
        public ActionResult Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Loan loan = db.Loans.Find(id);
            if (loan == null)
            {
                return HttpNotFound();
            }
            return View(loan);
        }

        // GET: Loans/Create
        public ActionResult Create()
        {
            ViewBag.BookId = new SelectList(db.Books, "Id", "Isbn10");
            ViewBag.BorrowerId = new SelectList(db.Borrowers, "Id", "Name");
            return View();
        }

        // POST: Loans/Create
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create([Bind(Include = "Id,BookId,BorrowerId,BorrowedOn,ReturnedOn")] Loan loan)
        {
            if (ModelState.IsValid)
            {
                db.Loans.Add(loan);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            ViewBag.BookId = new SelectList(db.Books, "Id", "Isbn10", loan.BookId);
            ViewBag.BorrowerId = new SelectList(db.Borrowers, "Id", "Name", loan.BorrowerId);
            return View(loan);
        }

        // GET: Loans/Edit/5
        public ActionResult Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Loan loan = db.Loans.Find(id);
            if (loan == null)
            {
                return HttpNotFound();
            }
            ViewBag.BookId = new SelectList(db.Books, "Id", "Isbn10", loan.BookId);
            ViewBag.BorrowerId = new SelectList(db.Borrowers, "Id", "Name", loan.BorrowerId);
            return View(loan);
        }

        // POST: Loans/Edit/5
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "Id,BookId,BorrowerId,BorrowedOn,ReturnedOn")] Loan loan)
        {
            if (ModelState.IsValid)
            {
                db.Entry(loan).State = EntityState.Modified;
                db.SaveChanges();
                return RedirectToAction("Index");
            }
            ViewBag.BookId = new SelectList(db.Books, "Id", "Isbn10", loan.BookId);
            ViewBag.BorrowerId = new SelectList(db.Borrowers, "Id", "Name", loan.BorrowerId);
            return View(loan);
        }

        // GET: Loans/Delete/5
        public ActionResult Delete(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Loan loan = db.Loans.Find(id);
            if (loan == null)
            {
                return HttpNotFound();
            }
            return View(loan);
        }

        // POST: Loans/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            Loan loan = db.Loans.Find(id);
            db.Loans.Remove(loan);
            db.SaveChanges();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}


text:
SET enable_seqscan to false;

-- test search for "not equals"

CREATE TABLE test_ne (
   a  TIMESTAMP,
   b  NUMERIC
);
CREATE INDEX test_ne_idx ON test_ne USING gist (a, b);

INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000);
INSERT INTO test_ne VALUES('2007-02-03', -91.3);
INSERT INTO test_ne VALUES('2011-09-01', 43.7);
INSERT INTO test_ne SELECT '2009-01-01', 10.7 FROM generate_series(1,1000);

SET enable_indexscan to false;

EXPLAIN (COSTS OFF) SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7;

SELECT * FROM test_ne WHERE a <> '2009-01-01' AND b <> 10.7;

RESET enable_indexscan;

-- The below test use an exclusion constraint, which isn't supported in GPDB
-- so we need to ignore this test
-- start_ignore
-- test search for "not equals" using an exclusion constraint

CREATE TABLE zoo (
   cage   INTEGER,
   animal TEXT,
   EXCLUDE USING gist (cage WITH =, animal WITH <>)
);

INSERT INTO zoo VALUES(123, 'zebra');
INSERT INTO zoo VALUES(123, 'zebra');
INSERT INTO zoo VALUES(123, 'lion');
INSERT INTO zoo VALUES(124, 'lion');
-- end_ignore


text:
package p06_birthdayCelebrations.models.impl;

import p06_birthdayCelebrations.models.contracts.Robot;

public class RobotImpl implements Robot {

    private String model;
    private String id;

    public RobotImpl(String model, String id) {
        this.model = model;
        this.id = id;
    }

    @Override
    public String getId() {
        return this.id;
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Rxns.Collections;
using Rxns.Logging;
using Rxns.Metrics;
using Rxns.Playback;

namespace Rxns.Health.AppStatus
{
    /// <summary>
    /// The repository used to store system error information
    /// </summary>
    public interface IErrorRepository
    {
        /// <summary>
        /// Retrieves errors from the store
        /// </summary>
        /// <param name="where">A clause which constrains the results</param>
        /// <param name="pageWith">Paging data used to contrain the results</param>
        /// <returns>The metrics which match the conditions</returns>
        IEnumerable<SystemErrors> GetErrors(Func<SystemErrors, bool> where = null, Page pageWith = null);

        /// <summary>
        /// Retrieves error log information from the store
        /// </summary>
        /// <param name="where">A clause which constrains the results</param>
        /// <returns>The metrics which match the conditions</returns>
        IObservable<SystemLogMeta> GetErrorMeta(string errorId, Func<SystemLogMeta, bool> where = null);

        /// <summary>
        /// Adds an error report the store
        /// </summary>
        /// <param name="report">The report</param>
        /// <returns>The ID of the error in the store</returns>
        string AddError(BasicErrorReport report);

        /// <summary>
        /// Adds a error log information the database
        /// </summary>
        /// <param name="meta">The log information for an error. Ensure the ErrorId is correctly set</param>
        /// <returns>The ID of the error log information in the store</returns>
        void AddErrorMeta(string errorReportId, SystemLogMeta[] meta);

        /// <summary>
        /// Removes an error
        /// </summary>
        /// <param name="errorId">The id of the error to delete</param>
        void DeleteError(long errorId);

        /// <summary>
        /// Removes an metric
        /// </summary>
        /// <param name="metricId">The id of the metric to delete</param>
        void DeleteMetric(long metricId);
    }
}


text:
<ion-header>
  <ion-navbar primary>
    <ion-buttons start>
      <button menuToggle>
        <ion-icon name="menu"></ion-icon>
      </button>
    </ion-buttons>

    <ion-title>
    POI of the location
    </ion-title>

    <ion-buttons end>
      <button  ion-button icon-only (click)="loginfbstatus()">
        <ion-icon ios="logo-facebook"  md="logo-facebook"></ion-icon>
      </button>
      <button ion-button icon-only  (click)="showlistofpoi()">
        <ion-icon ios="ios-list" md="md-list"></ion-icon>
      </button>
      <button ion-button icon-only>
        <ion-icon ios="ios-sync" md="md-sync"></ion-icon>
      </button>
      <button ion-button icon-only>
        <ion-icon name="search"></ion-icon>
      </button>
    </ion-buttons>
  </ion-navbar>
</ion-header>
<ion-content scroll="false">

</ion-content>


text:
layout: error
---

404 Page Not Found!

error_outline

home